ConfigBase class defines the basic interface of all config classes. It can
not be used by itself (it is an abstract base class) and you will always use one
of its derivations: FileConfig,
RegConfig or any other.
However, usually you don’t even need to know the precise nature of the class
you’re working with but you would just use the ConfigBase methods. This
allows you to write the same code regardless of whether you’re working with
the registry under Win32 or text-based config files under Unix (or even
Windows 3.1 .INI files if you’re really unlucky). To make writing the portable
code even easier, Widgets provides a typedef Config
which is mapped onto the native ConfigBase implementation on the given
platform: i.e. RegConfig under Win32 and
FileConfig otherwise.
See config overview for the descriptions of all
features of this class.
It is highly recommended to use static functions Get() and/or Set(),
so please have a look at them.
No base class
Here is how you would typically use this class:
// using Config instead of writing FileConfig or RegConfig enhances // portability of the code Config *config = new Config(“MyAppName”); String str; if ( config→Read(“LastPrompt”, &str) ) { // last prompt was found in the config file/registry and its value is now // in str … } else { // no last prompt… } // another example: using default values and the full path instead of just // key name: if the key is not found , the value 17 is returned long value = config→Read(“/LastRun/CalculatedValues/MaxValue”, 17); … … … // at the end of the program we would save everything back config→Write(“LastPrompt”, str); config→Write(“/LastRun/CalculatedValues/MaxValue”, value); // the changes will be written back automatically delete config;This basic example, of course, doesn’t show all Config features, such as
enumerating, testing for existence and deleting the entries and groups of
entries in the config file, its abilities to automatically store the default
values or expand the environment variables on the fly. However, the main idea
is that using this class is easy and that it should normally do what you
expect it to.
NB: in the documentation of this class, the words “config file” also mean
“registry hive” for RegConfig and, generally speaking, might mean any
physical storage where a ConfigBase-derived class stores its data.
These functions deal with the “default” config object. Although its usage is
not at all mandatory it may be convenient to use a global config object
instead of creating and deleting the local config objects each time you need
one (especially because creating a FileConfig object might be a time
consuming operation). In this case, you may create this global config object
in the very start of the program and Set() it as the default. Then, from
anywhere in your program, you may access it using the Get() function.
Note that you must delete this object (usually in App#on_exit)
in order to avoid memory leaks, Widgets won’t do it automatically.
As it happens, you may even further simplify the procedure described above:
you may forget about calling Set(). When Get() is called and there
is no current object, it will create one using Create() function. To
disable this behaviour DontCreateOnDemand() is provided.
Note: You should use either Set() or Get() because Widgets
library itself would take advantage of it and could save various information
in it. For example FontMapper or Unix version
of FileDialog have the ability to use Config class.
As explained in config overview, the config classes
support a file system-like hierarchy of keys (files) and groups (directories).
As in the file system case, to specify a key in the config class you must use
a path to it. Config classes also support the notion of the current group,
which makes it possible to use the relative paths. To clarify all this, here
is an example (it is only for the sake of demonstration, it doesn’t do anything
sensible!):
Warning: it is probably a good idea to always restore the path to its
old value on function exit:
because otherwise the assert in the following example will surely fail
(we suppose here that foo() function is the same as above except that it
doesn’t save and restore the path):
Finally, the path separator in ConfigBase and derived classes is always ‘/’,
regardless of the platform (i.e. it is not ‘$$’ under Windows).
The functions in this section allow to enumerate all entries and groups in the
config file. All functions here return when there are no more items.
You must pass the same index to GetNext and GetFirst (don’t modify it).
Please note that it is not the index of the current item (you will have
some great surprises with RegConfig if you assume this) and you shouldn’t
even look at it: it is just a “cookie” which stores the state of the
enumeration. It can’t be stored inside the class because it would prevent you
from running several enumerations simultaneously, that’s why you must pass it
explicitly.
Having said all this, enumerating the config entries/groups is very simple:
ConfigBase *config = …; ArrayString aNames; // enumeration variables String str; long dummy; // first enum all entries bool bCont = config→GetFirstEntry(str, dummy); while ( bCont ) { aNames.Add(str); bCont = GetConfig()→GetNextEntry(str, dummy); } … we have all entry names in aNames… // now all groups… bCont = GetConfig()→GetFirstGroup(str, dummy); while ( bCont ) { aNames.Add(str); bCont = GetConfig()→GetNextGroup(str, dummy); } … we have all group (and entry) names in aNames…There are also functions to get the number of entries/subgroups without
actually enumerating them, but you will probably never need them.
These function are the core of ConfigBase class: they allow you to read and
write config file data. All Read function take a default value which
will be returned if the specified key is not found in the config file.
Currently, only two types of data are supported: string and long (but it might
change in the near future). To work with other types: for int or
bool you can work with function taking/returning long and just use the
casts. Better yet, just use long for all variables which you’re going to
save in the config file: chances are that sizeof(bool) == sizeof(int) == sizeof(long)
anyhow on your system. For float, double and, in
general, any other type you’d have to translate them to/from string
representation and use string functions.
Try not to read long values into string variables and vice versa: although it
just might work with FileConfig, you will get a system error with
RegConfig because in the Windows registry the different types of entries are
indeed used.
Final remark: the szKey parameter for all these functions can contain an
arbitrary path (either relative or absolute), not just the key name.
The functions in this section allow to rename entries or subgroups of the
current group. They will return on error. typically because either the
entry/group with the original name doesn’t exist, because the entry/group with
the new name already exists or because the function is not supported in this
Config implementation.
The functions in this section delete entries and/or groups of entries from the
config file. DeleteAll() is especially useful if you want to erase all
traces of your program presence: for example, when you uninstall it.
Some aspects of ConfigBase behaviour can be changed during run-time. The
first of them is the expansion of environment variables in the string values
read from the config file: for example, if you have the following in your
config file:
config->Read("UserData")
will return something like"/home/zeitlin/data"
if you’re lucky enough to run a Linux system ;-)Although this feature is very useful, it may be annoying if you read a value
which containts ‘\$’ or ‘\%’ symbols (\% is used for environment variables
expansion under Windows) which are not used for environment variable
expansion. In this situation you may call SetExpandEnvVars(false) just before
reading this value and SetExpandEnvVars(true) just after. Another solution
would be to prefix the offending symbols with a backslash.
The following functions control this option:
2
This is the default and only constructor of the ConfigBase class, and
derived classes.
foo=C:$
$mydir
insteadfoo=C:$
$mydir
.The CONFIG_USE_NO_ESCAPE_CHARACTERS style can be helpful if your config
file must be read or written to by a non-Widgets program (which might not
understand the escape characters). Note, however, that if
CONFIG_USE_NO_ESCAPE_CHARACTERS style is used, it is is now
your application’s responsibility to ensure that there is no newline or
other illegal characters in a value, before writing that value to the file.
By default, environment variable expansion is on and recording defaults is
off.
Empty but ensures that dtor of all derived classes is virtual.
Create a new config object: this function will create the “best”
implementation of Config available for the current platform, see comments
near the definition of CONFIG_WIN32_NATIVE for details. It returns the
created object and also sets it as the current one.
Calling this function will prevent Get() from automatically creating a
new config object if the current one is NULL. It might be useful to call it
near the program end to prevent “accidental” creation of a new config object.
Delete the whole underlying object (disk file, registry key, …). Primarly
for use by uninstallation routine.
Deletes the specified entry and the group it belongs to if it was the last key
in it and the second parameter is true.
Delete the group (with all subgroups)
returns if either a group or an entry with a given name exists
permanently writes all changes (otherwise, they’re only written from object’s
destructor)
Get the current config object. If there is no current object and
CreateOnDemand is true, creates one
(using Create) unless DontCreateOnDemand was called previously.
Returns the application name.
Returns the type of the given entry or Unknown if the entry doesn’t
exist. This function should be used to decide which version of Read() should
be used because some of Config implementations will complain about type
mismatch otherwise: e.g., an attempt to read a string value from an integer
key with RegConfig will fail.
The result is an element of enum EntryType:
enum EntryType { Type_Unknown, Type_String, Type_Boolean, Type_Integer, Type_Float };Gets the first group.
Gets the first entry.
Gets the next group.
Gets the next entry.
Get number of entries/subgroups in the current group, with or without its
subgroups.
Retrieve the current path (always as absolute path).
Returns the vendor name.
returns if the entry by this name exists
returns if the group by this name exists
Returns if we are expanding environment variables in key values.
Returns if we are writing defaults back to the config file.
Read a string from the key, returning if the value was read. If the key
was not found, str is not changed.
Read a string from the key. The default value is returned if the key was not
found.
Returns if value was really read, if the default was used.
String read(%(arg-type)String% key, String defaultVal)Another version of Read(), returning the string value directly.
Boolean read(%(arg-type)String% key, Integer l)Reads a long value, returning if the value was found. If the value was
not found, l is not changed.
Reads a long value, returning if the value was found. If the value was
not found, defaultVal is used instead.
Reads a long value from the key and returns it. defaultVal is returned
if the key is not found.
NB: writing
conf→Read(“key”, 0);won’t work because the call is ambiguous: compiler can not choose between two
Read functions. Instead, write:
Reads a double value, returning if the value was found. If the value was
not found, d is not changed.
Reads a double value, returning if the value was found. If the value was
not found, defaultVal is used instead.
Reads a bool value, returning if the value was found. If the value was
not found, b is not changed.
Reads a bool value, returning if the value was found. If the value was
not found, defaultVal is used instead.
Renames an entry in the current group. The entries names (both the old and
the new one) shouldn’t contain backslashes, i.e. only simple names and not
arbitrary paths are accepted by this function.
Returns if oldName doesn’t exist or if newName already
exists.
Renames a subgroup of the current group. The subgroup names (both the old and
the new one) shouldn’t contain backslashes, i.e. only simple names and not
arbitrary paths are accepted by this function.
Returns if oldName doesn’t exist or if newName already
exists.
Sets the config object as the current one, returns the pointer to the previous
current object (both the parameter and returned value may be NULL)
Determine whether we wish to expand environment variables in key values.
Set current path: if the first character is ‘/’, it is the absolute path,
otherwise it is a relative path. ‘..’ is supported. If strPath doesn’t
exist it is created.
Sets whether defaults are recorded to the config file whenever an attempt to
read the value which is not present in it is done.
If on (default is off) all default values for the settings used by the program
are written back to the config file. This allows the user to see what config
options may be changed and is probably useful only for FileConfig.
These functions write the specified value to the config file and return on success.
[This page automatically generated from the Textile source at 2023-06-03 08:07:28 +0000]