Free sn software for linux

SimpleIni is a cross-platform library that provides a simple API to read and write INI-style configuration files. It supports data files in ASCII, MBCS and Unicode.
It is designed explicitly to be portable to any platform and has been tested on Windows and Linux. Released as open-source and free using the MIT licence.
Examples:
These snippets are included with the distribution in the file snippets.cpp.
LOADING DATA
load from a data file
CSimpleIniA ini(a_bIsUtf8, a_bUseMultiKey, a_bUseMultiLine);
SI_Error rc = ini.LoadFile(a_pszFile);
if (rc < 0) return false;
load from a string
std::string strData;
rc = ini.Load(strData.c_str(), strData.size());
if (rc < 0) return false;
GETTING SECTIONS AND KEYS
get all sections
CSimpleIniA::TNamesDepend sections;
ini.GetAllSections(sections);
get all keys in a section
CSimpleIniA::TNamesDepend keys;
ini.GetAllKeys("section-name", keys);
GETTING VALUES
get the value of a key
const char * pszValue = ini.GetValue("section-name",
"key-name", NULL /*default*/);
get the value of a key which may have multiple values. If bHasMultipleValues is true, then just one value has been returned
bool bHasMultipleValues;
pszValue = ini.GetValue("section-name", "key-name",
NULL /*default*/, &bHasMultipleValues);
get all values of a key with multiple values
CSimpleIniA::TNamesDepend values;
ini.GetAllValues("section-name", "key-name", values);
sort the values into the original load order
values.sort(CSimpleIniA::Entry::LoadOrder());
output all of the items
CSimpleIniA::TNamesDepend::const_iterator i;
for (i = values.begin(); i != values.end(); ++i) {
printf("key-name = %sn", i->pItem);
}
MODIFYING DATA
adding a new section
rc = ini.SetValue("new-section", NULL, NULL);
if (rc < 0) return false;
printf("section: %sn", rc == SI_INSERTED ?
"inserted" : "updated");
adding a new key ("new-section" will be added automatically if it doesnt already exist)
rc = ini.SetValue("new-section", "new-key", "value");
if (rc < 0) return false;
printf("key: %sn", rc == SI_INSERTED ?
"inserted" : "updated");
changing the value of a key
rc = ini.SetValue("section", "key", "updated-value");
if (rc < 0) return false;
printf("key: %sn", rc == SI_INSERTED ?
"inserted" : "updated");
DELETING DATA
deleting a key from a section. Optionally the entire section may be deleted if it is now empty.
ini.Delete("section-name", "key-name",
true /*delete the section if empty*/);
deleting an entire section and all keys in it
ini.Delete("section-name", NULL);
SAVING DATA
save the data to a string
rc = ini.Save(strData);
if (rc < 0) return false;
save the data back to the file
rc = ini.SaveFile(a_pszFile);
if (rc < 0) return false;
Enhancements:
- Fixed a bug causing multi-line values and comments to get corrupted. This affects only files with CR LF line endings (Windows) and wchar_t/ICU interface (Unicode).

libwayne is a library of reasonably abstract datatypes and algorithms written in C.

The algorithms in libwayne are by no means original. Many of them are taken verbatim from textbooks on data structures and algorithms, and I simply translated them into C. They include efficient and correct routines for priority queues, event-driven simulations, queues, stacks, binary trees, sets of integers, graphs (the node-edge kind), some combinatorics routines, ODE integration routines, a simple statistics package, and a matrix-vector library.

Many of the routines (heap, stack, queue, bintree) can work with arbitrary objects, not just integers. Comparisons are done with pointers to comparison functions, similar to ANSI Cs standard qsort. This library is not meant to be complete; I write the routines as I need them, but only high-quality code goes into libwayne.

One thing that many people ask me is ``why didnt you use C++? Without going into a long tirade, suffice it to say that, although I am not a C++ expert (actually, the only stuff I havent learned in intimate detail is templates), I know enough C++ to realize that it is not the be-all, end-all of programming languages. In fact, after several years of C++ being around, it is already beginning a slow fading into history, with Java being its successor --- and not a very good one, at that.

At the risk of sounding like the 40-50 year olds out there who still insist that FORTRAN is a good enough language for everything, Ill be a 30-something who insists that, until something better comes along, C is still a good all-purpose language in which to write heavy, data-structure intensive programs. I believe it was Dennis Ritchie who said something like, "C is rarely the best language for a given task, but its often the second-best," the implication being that its better to learn one language that is second-best for everything, than to learn a new language for every programming task. (One could say the same of English.)

I started libwayne when I realized that I was constantly re-writing little bits of code that did important things that should be in the C standard, but are not. For example, how many times have you written code like this:
if((p = malloc(n)) == NULL) /* or some other fatal error condition */
{
fprintf(stderr, "error: %sn", err_msg);
exit(1);
}

I got sick of it. Furthermore, I often wanted to know more about why my program failed. So I wrote Fatal. Heres its prototype:
void Fatal(char *fmt, ...); /* generates an assertion failure */

It uses varargs so you can pass it an arbitrary list of output arguments just like printf, but it generates an assertion failure so that if you run it under a debugger, you can look at the program nicely as it dies. It turned out to be only the first function I wrote for libwayne, and it was put into a file called "misc.c" which I started including in most of the code I wrote. Another early member of the library was Malloc, which calls Fatal if the standard malloc fails.

Eventually "misc.c" started getting pretty big, with macros for MIN, MAX, ABS, SQR, etc, so I created misc.h and compiled misc.c into an object module. That was about 1993.

About that time I started to realize that, at least in C, we need a way to pass "objects" around in a reasonably transparent way, but sometimes we want to treat pointers as integers. This makes some peoples teeth sweat (my own included), so I invented the voint datatype, which is (you guessed it) a union of (void*) and (int).

Then I started adding more complex algorithms to libwayne, whenever I needed them. Each and every piece of libwayne was written because I needed it, but only things that I took careful time to do well went into libwayne. Any algorithm that needs to compare objects needs a comparison function like the one used by the ANSI standard qsort routine.

Persistent::LDAP is a persistent class implemented using a LDAP directory.

SYNOPSIS

use Persistent::LDAP;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $person =
new Persistent::LDAP(localhost, 389,
cn=Directory Manager, test1234,
ou=Engineering,o=Big Snow Org,c=US);

### declare attributes of the object ###
$person->add_attribute(uid, ID, String);
$person->add_attribute(userpassword, Persistent, String);
$person->add_attribute(objectclass, Persistent, String);
$person->add_attribute(givenname, Persistent, String);
$person->add_attribute(sn, Persistent, String);
$person->add_attribute(cn, Persistent, String);
$person->add_attribute(mail, Persistent, String);
$person->add_attribute(telephonenumber, Persistent, String);

### query the datastore for some objects ###
$person->restore_where(& (objectclass=person)(mail=*bigsnow.org),
sn, givenname);
while ($person->restore_next()) {
printf("name = %s, email = %sn",
$person->givenname . . $person->sn,
$person->mail);
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses a LDAP directory to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Persistent::MySQL is a persistent class implemented using a MySQL database.

SYNOPSIS

use Persistent::MySQL;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $emp = new Persistent::MySQL($data_source, $username, $password, $table);

### define attributes of the object ###
$emp->add_attribute(empno, ID, Number, undef, 4);
$emp->add_attribute(ename, Persistent, VarChar, undef, 10);
$emp->add_attribute(job, Persistent, VarChar, undef, 9);
$emp->add_attribute(mgr, Persistent, Number, undef, 4);
$emp->add_attribute(hiredate, Persistent, DateTime, undef);
$emp->add_attribute(sal, Persistent, Number, undef, 7, 2);
$emp->add_attribute(comm, Persistent, Number, undef, 7, 2);
$emp->add_attribute(deptno, Persistent, Number, undef, 2);

### query the datastore for some objects ###
$emp->restore_where(qq{
sal > 1000 and
job = CLERK and
ename LIKE M%
}, "sal, ename");
while ($emp->restore_next()) {
printf "ename = %s, emp# = %s, sal = %s, hiredate = %sn",
$emp->ename, $emp->empno, $emp->sal, $emp->hiredate;
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses a MySQL database table to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Persistent::Oracle is a persistent class implemented using an Oracle database.

SYNOPSIS

use Persistent::Oracle;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $emp = new Persistent::Oracle(dbi:Oracle:ORCL,
scott, tiger, emp);

### define attributes of the object ###
$emp->add_attribute(empno, ID, Number, undef, 4);
$emp->add_attribute(ename, Persistent, VarChar, undef, 10);
$emp->add_attribute(job, Persistent, VarChar, undef, 9);
$emp->add_attribute(mgr, Persistent, Number, undef, 4);
$emp->add_attribute(hiredate, Persistent, DateTime, undef);
$emp->add_attribute(sal, Persistent, Number, undef, 7, 2);
$emp->add_attribute(comm, Persistent, Number, undef, 7, 2);
$emp->add_attribute(deptno, Persistent, Number, undef, 2);

### query the datastore for some objects ###
$emp->restore_where(qq{
sal > 1000 and
job = CLERK and
ename LIKE M%
}, "sal, ename");
while ($emp->restore_next()) {
printf "ename = %s, emp# = %s, sal = %s, hiredate = %sn",
$emp->ename, $emp->empno, $emp->sal, $emp->hiredate;
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses an Oracle database table to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Locale::SubCountry is a Perl module that can convert state, province, county etc. names to/from code.

SYNOPSIS

my $country_code = GB;
my $UK = new Locale::SubCountry($country_code);
if ( not $UK )
{
die "Invalid code $country_coden";
}
elsif ( $UK->has_sub_countries )
{
print($UK->full_name(DGY),"n"); # Dumfries and Galloway
print($UK->regional_division(DGY),"n"); # CT (Scotland)
}

my $australia = new Locale::SubCountry(AUSTRALIA);
print($australia->country,"n"); # AUSTRALIA
print($australia->country_code,"n"); # AU

if ( $australia->has_sub_countries )
{
print($australia->code(New South Wales ),"n"); # NSW
print($australia->full_name(S.A.),"n"); # South Australia
my $upper_case = 1;
print($australia->full_name(Qld,$upper_case),"n"); # QUEENSLAND
print($australia->category(NSW),"n"); # state
print($australia->FIPS10_4_code(ACT),"n"); # 01
print($australia->ISO3166_2_code(02),"n"); # NSW

my @aus_state_names = $australia->all_full_names;
my @aus_code_names = $australia->all_codes;
my %aus_states_keyed_by_code = $australia->code_full_name_hash;
my %aus_states_keyed_by_name = $australia->full_name_code_hash;

foreach my $code ( sort keys %aus_states_keyed_by_code )
{
printf("%-3s : %sn",$code,$aus_states_keyed_by_code{$code});
}
}

# Methods for country codes and names

my $world = new Locale::SubCountry::World;
my @all_countries = $world->all_full_names;
my @all_country_codes = $world->all_codes;

my %all_countries_keyed_by_name = $world->full_name_code_hash;
my %all_country_keyed_by_code = $world->code_full_name_hash;

This module allows you to convert the full name for a countries administrative region to the code commonly used for postal addressing. The reverse lookup can also be done. Sub country codes are defined in "ISO 3166-2:1998, Codes for the representation of names of countries and their subdivisions".

Sub countries are termed as states in the US and Australia, provinces in Canada and counties in the UK and Ireland.

Names and ISO 3166-2 codes for all sub countries in a country can be returned as either a hash or an array.

Names and ISO 3166-1 codes for all countries in the world can be returned as either a hash or an array.

ISO 3166-2 codes can be converted to FIPS 10-4 codes. The reverse lookup can also be done.

MP4::Info is a Perl module that can fetch info from MPEG-4 files (.mp4, .m4a, .m4p, .3gp).

SYNOPSIS

#!perl -w
use MP4::Info;
my $file = Pearls_Before_Swine.m4a;

my $tag = get_mp4tag($file) or die "No TAG info";
printf "$file is a %s trackn", $tag->{GENRE};

my $info = get_mp4info($file);
printf "$file length is %d:%dn", $info->{MM}, $info->{SS};

my $mp4 = new MP4::Info $file;
printf "$file length is %s, title is %sn",
$mp4->time, $mp4->title;

The MP4::Info module can be used to extract tag and meta information from MPEG-4 audio (AAC) and video files. It is designed as a drop-in replacement for MP3::Info.