Free xml abstraction software for linux

The CAN Abstraction Layer (CANAL) provides a single interface for programs to use different CAN drivers.
It consists of a CANAL daemon that handles client and driver communication, a canalLogger that logs messages in a window, and a simple diagnostic application. C++ clases and DLL/DL interfaces are provided.
Enhancements:
- The configuration readings for CanalWorks were upgraded.
- A GUID ordering problem in canald was fixed.
- A problem with clear message list switch in CanalWorks was fixed.
- A problem in which Linux version Level I received a thread with an invalid count returned for DataAvailable was fixed.

XML::Conf is a simple configuration module based on XML.

SYNOPSIS

Here follows some examples as the tests are done.

use XML::Conf;
my $c = XML::Conf->new($filename);
$w = $c->FIRSTKEY();
$v = $c->NEXTKEY();
$c->EXISTS($v);
$c->DELETE($v);
$c->CLEAR();

This is the description of the class, currently it only containg only the descriptions of the private and public methods and attributes.

XML Security Library is a C library based on LibXML2.
The library supports major XML security standards:
- XML Signature
- XML Encryption
- Canonical XML (was included in LibXML2)
- Exclusive Canonical XML (was included in LibXML2)
XML Security Library is released under the MIT Licence see the Copyright file in the distribution for details.

Database Independent Abstraction Layer for C (libdbi) implements a database-independent abstraction layer in C, similar to the DBI/DBD layer in Perl.
Writing one generic set of code, programmers can leverage the power of multiple databases and multiple simultaneous database connections by using this framework.
Main features:
Database-level abstraction:
Your programs dont need to deal with the arbitrary interfaces and oddities of each database library. libdbi handles all the details for you, you just tell it what you want the database to do.
Modularity:
Since database code written with libdbi is not tied to one specific database server, you can effortlessly switch databases or give your users the option to specify their own database settings.
Clean interface:
With ample documentation describing libdbi and its well thought out object-oriented design, programming with libdbi should be less painful than programming with native database libraries. And you only need to learn it once instead of learning each database librarys syntax.
Accommodates coder apathy:
libdbi is written to do The Right Thing(tm), not just some quick hack that does the job in a half-assed fashion. This saves tons of your $100/hour time from debugging, so that you can mess around having fun during the hours that clients are paying you to debug. It also strives to reduce the worldwide crisis of carpal tunnel syndrome, so it uses constructs such as this one to pack multiple function calls into one line, saving you the bother of typing more than you have to:
dbi_result_get_fields(result, "id.%i firstname.%s lastname.%s fractional_value.%f", &id, &firstname, &lastname, &floatval);
Driver interface:
The dynamic linking used by libdbi allows for driver authors to license their drivers however they please - they are not restricted to the GPL or LGPL. Drivers are easy to write, and require no special installation.
Error handling:
Instead of checking every single database call for errors, libdbi gives programmers the option of registering an error handler callback, similar to a signal handler. Because we know youll "forget" to check for errors otherwise :)
Convenience:
Spend your time writing clever code, not reinventing the wheel with your own single-use, #define-abusing, less featureful database interface.
libdbi implements a database-independent abstraction layer in C, similar to the DBI/DBD layer in Perl. Writing one generic set of code, programmers can leverage the power of multiple databases and multiple simultaneous database connections by using this framework.
The libdbi-drivers project maintains drivers for libdbi. Drivers are distributed seperately from the library itself.
There are currently drivers for MySQL, PostgreSQL, SQLite, and mSQL. More are on the way.
Enhancements:
- Support for a timezone suffix in time and date types was added.
- Error handling and error reporting were vastly improved.
- Some memory leaks were fixed.

1060 NetKernel is a resource oriented microkernel and application server that provides a coherent execution abstraction that radically reduces software complexity. Its self-consistent design is based on the convergence and unification of powerful fundamental concepts found in the World Wide Web and Unix.
Resource Oriented Microkernel
The heart of NetKernel is a high-performance, carefully designed, and tightly crafted microkernel. Services and resources within NetKernel are located by URI addresses, just as resources are located on the World Wide Web. NetKernel implements and extends REST 1 into a general-purpose processing abstraction and allows it to be applied to the finest granularity of software systems to achieve phenominal performance; just as the REST Web-architecture achieves global scaling and high performance.
Coherent Abstraction
NetKernel unifies code execution and resource identification into a single addressing and processing abstraction. With this, software development becomes a process of construction (coding services), composition (linking and issuing service and resource requests), and constraint (restricting data values and honoring boundaries).
The simplicity of URI identified resources means that the results of service calls can be cached just as other resources, resulting in self-optimizing software where computation cost is a guaranteed minima.
Reduce Software Complexity
The unification of resources and services with URI addressing radically reduces sofware complexity. Because resources are addressed by URI and each request is a Web-like REST request dispatched to the microkernel, binding between clients and services occurs dynamically for each request. This late binding and the indirection of logical URI addressing results in a loosely coupled system which may be easily adapted. In fact, NetKernel supports dynamic upgrading of software and can support multiple versions of the same components simultaneously.
Complexity brought about by system growth is also managed through the URI address space which may be remodelled and extended indefinitely. A complex aggregation of services may always be abstracted into one or more higher-level services surfaced through URI interfaces.
Main features:
Manage Complexity
- NetKernels unification of resource and service addressing through the active URI scheme combined with late binding and loose typing means that complex systems can be partitioned not just into smaller coorperating systems, you can now create micro-services that hide complexity.
- With NetKernel, design and build larger and more ambitious systems while maintaining control of complexity.
Process XML with ease!
- Processing XML is often just too difficult. But the potential of XML is communication with almost no limit. How to harness and leverage the potential of XML? NetKernel provides hundreds of XML technologies as simple services (no APIs). Simply compose XML services into powerful message processes...
Integrate diverse technologies, apply business logic
- NetKernels uniform URI addressing of resources and service allow you to encapsulate and hide the complexities of any technology, whether it is a Java API, legacy code, or remote corporate systems. Once encapsulated, develop new coordination logic in one of NetKernels scripting languages.
Transport technology independence
- Write a service or application and deploy it to service requests from multiple transports concurrently. NetKernel makes it easy to utilize SOAP 1.1, SOAP 1.2, HTTP, JMS, Email, and Cron.
Extreme performance from intra-application caching
- NetKernels fine-grained dependency cache transparently and opportunistically caches the results of all micro-service requests. NetKernel processes are self-optimizing with guaranteed minimal processing required for a given transaction.
Team Player
- NetKernel has several deployment options that allow it to play well with other technologies and systems. Deploy NetKernel as an advanced standalone application server, as an embedded "co-processor" within existing J2EE applications, as a JMS message processor, as a SOAP client or server, or as an embedded component within any application.
Enhancements:
- New features include support for Berkeley DBXML and PiNKY, a community developed module providing Yahoo! Pipes features.
- Updates include Groovy language support at release 1.0, Ruby (JRuby) support at 0.9.9, and XML library updates.
- There are also documentation updates and UI refinements.

XML::SAX is a simple API for XML.

SYNOPSIS

use XML::SAX;

# get a list of known parsers
my $parsers = XML::SAX->parsers();

# add/update a parser
XML::SAX->add_parser(q(XML::SAX::PurePerl));

# remove parser
XML::SAX->remove_parser(q(XML::SAX::Foodelberry));

# save parsers
XML::SAX->save_parsers();

XML::SAX is a SAX parser access API for Perl. It includes classes and APIs required for implementing SAX drivers, along with a factory class for returning any SAX parser installed on the users system.

XML::Bare is a minimal XML parser implemented via a C state engine.

SYNOPSIS

use XML::Bare;

my $xml = new XML::Bare( text => Bob );

# Parse the xml into a hash tree
my $root = $xml->parse();

# Print the content of the name node
print $root->{xml}->{name}->{value};

# Load xml from a file ( assume same contents as first example )
my $xml2 = new XML::Bare( file => test.xml );

my $root2 = $xml2->parse();

$root2->{xml}->{name}->{value} = Tim;

# Save the changes back to the file
$xml2->save();