Free edit config files 1.7.5 software for linux

Simple Config library supports configuration files consisting of simple name-value pairs, similar to the old Windows INI files. A config file can be loaded into memory, queried by item name, modified, and written back out to a file. Configuration items may also be "watched", which causes a user-supplied callback function to be called with the named item is modified
Client code can query the configuration system for named values, set named values, test the type of values (STR, INT, FIX, BOOL, DATE or TIME) and watch values for changes. The system can update the configuration file when the application has changed or added values, even preserving the original format and commens from the input configuration file.
Theres not much to it, at the moment, not even a manpage, so youre on your own as far as using the library. There is a ReadMe file and a makefile, so you can easily build and install the library.
The whole thing took about a week to design, code and test, so its no heroic effort or anything. With a bit more time and energy it could probably be something really spectacular. My main point was that, given the simple problem statement, it was (relatively) trivial to code up a conforming solution.
Enhancements:
- The hashtable code was updated.
- No changes were made to functionality, but it is now more heap-friendly with less heap fragmentation and faster bucket allocation.
- The ground work for automatic table resizing has been laid.

Config::JSON is a JSON based config file system.

SYNOPSIS

use Config::JSON;

my $config = Config::JSON->create($pathToFile);
my $config = Config::JSON->new($pathToFile);

my $element = $config->get($param);

$config->set($param,$value);

$config->delete($param);
$config->deleteFromHash($name, $key);
$config->deleteFromArray($name, $value);

$config->addToHash($name, $key, $value);
$config->addToArray($name, $value);

my $path = $config->getFilename;
Example Config File
# config-file-type: JSON 1

{
"dsn" : "DBI:mysql:test",
"user" : "tester",
"password" : "xxxxxx",

# some colors to choose from
"colors" : [ "red", "green", "blue" ],

# some statistics
"stats" : {
"health" : 32,
"vitality" : 11
}
}

Note that you can put comments in the config file as long as # is the first non-space character on the line. However, if you use this API to write to the config file, your comments will be eliminated.

dtRdr::Config is a Perl module with Factory class for configuration system.

Factory Methods

factory_read_config

Constructor function (see new)

my $obj = factory_read_config($file);

new

$conf = dtRdr::Config->new($file);

get_library_info

my @libraries = $conf->get_library_info;

Config::Framework is a Perl module with handy one-stop shopping for (most) of your configuration file needs.

SYNOPSIS

#create a new object, load two configuration files and decrypt the passwords. my $Object = new Config::Framework( Files => [ApplicationCfg.xml,UserCfg.xml], GetSecure => 1 ) || die $Config::Framework::errstr;

#change some data in one of the loaded configs $Object->{UserCfg}->{backgroundColor} = #00CCFF;

#write that change back to the file you loaded it from $Object->WriteConfig(configNamespace => "UserCfg") || die $Object->{errstr};

#Define a new configuration namespace %{ $Object->{newConfig} } = ( configNamespace => "newConfig", protectNamespace => 1, Version => 1, #arbitrary data keys follow backgroundColor => #006699, getRecords => 10, followLinks => 1, someThing => "in a bag" );

#Write your new configuration data out to an encrypted file #under the applications ApplicationFramework directory $Object->WriteConfig( configNamespace => "newConfig", Encrypt => 1, Crypt => "Rijndael", Key => "l33tp4sw3rd" File => "$Object->{FrameworkDir}/newConfig.xml" ) || die $Object->{errstr};

At long last I have decided to re-write the documentation for Config::Framework, in a manner which should be comprehensible by people other than myself. I would like to offer my sincerest appologies to anyone who tried to comprehend the sprawling stream-of-consiousness rant that was the previous documentation. Im sorry, I wasnt trying to make you insane. Now on with the show.

Ok so what is Config::Framework? Its a handy module for dealing with situations where you need your program to be able to load external data from a file that controls how your program operates. Im talking about configuration files here. So what do you do in a situation like that? Well you figure out a format to store your configuration parameters in, then write routines to read that format and put it some sort of meaningful data structure, and to write data from the data structure back out to the file.

Wouldnt it be nice if someone defined a standard config file format so that you wouldnt need to write your own parser? Well in the end, all a config file really is, is an arbitrary data structure expressed in in ascii. A standard way of serializing data structures in ascii you say? That sounds a bit like XML! Well the Data::DumpXML module will serialize perl data structures into XML and restore them for you, and you could certainly dump that to a file easily enough.
Ok getting to the point. The main thing that Config::Framework does for you is to define a standard data structure (or at least some standard guidelines for your data structure) and then front-ends Data::DumpXML so that you can arbitrarily dump and restore these data structures to files.

While were at it, Config::Framework aspires to be your one-stop-shop for config-type-stuff, by helping you stay organized in the way you handle external configuration data.

Log::Dispatch::Config is a Log4j for Perl.

SYNOPSIS

use Log::Dispatch::Config;
Log::Dispatch::Config->configure(/path/to/log.conf);

my $dispatcher = Log::Dispatch::Config->instance;
$dispatcher->debug(this is debug message);
$dispatcher->emergency(something *bad* happened!);

# automatic reloading conf file, when modified
Log::Dispatch::Config->configure_and_watch(/path/to/log.conf);

# or if you write your own config parser:
use Log::Dispatch::Configurator::XMLSimple;

my $config = Log::Dispatch::Configurator::XMLSimple->new(log.xml);
Log::Dispatch::Config->configure($config);

Log::Dispatch::Config is a subclass of Log::Dispatch and provides a way to configure Log::Dispatch object with configulation file (default, in AppConfig format). I mean, this is log4j for Perl, not with all API compatibility though.

METHOD

This module has a class method configure which parses config file for later creation of the Log::Dispatch::Config singleton instance. (Actual construction of the object is done in the first instance call).

So, what you should do is call configure method once in somewhere (like startup.pl in mod_perl), then you can get configured dispatcher instance via Log::Dispatch::Config->instance.