Free compound software for linux

Mr. Persister is a simple, small, object relational mapping API capable of reading Java objects from, and writing Java objects to relational databases. It was first released july 2004.
Main features:
- Fast! (Faster than Hibernate)
- Read objects of any size in just 3-5 lines of code.
- Automatic and manual mapping of objects to database tables.
- No config files required.
- SQL as query language.
- Automatic connection and transaction management
- (via DAO commands).
- Automatic connection and transaction management
- (via connection and transaction scoping).
- Automatic SQL generation for most trivial tasks.
- Batch updates of multiple objects.
- Compound primary key support.
- Partial object reading and writing.
- Read Filters.
- Simplifies trivial JDBC tasks.
- Interleave custom JDBC with Mr. Persister operations.
- Fully Pluggable Design.
- Well Tested. 290 unit tests were executed against each supported database.
Enhancements:
- Mr. Persister now uses JDK 5.0.
- Some important bugs have been fixed, and the software now enables annotation-based class-to-database mappings both as an alternative and a supplement to automatic and programmatic mapping.

KDE is a powerful Free Software graphical desktop environment for Linux and Unix workstations.

It combines ease of use, contemporary functionality, and outstanding graphical design with the technological superiority of the Unix operating system.

KDE is a network transparent contemporary desktop environment for UNIX workstations. KDE seeks to fill the need for an easy to use desktop for Unix workstations, similar to the desktop environments found under the MacOS or Microsoft Windows.

We believe that the UNIX operating system is the best operating system available today. In fact UNIX has been the undisputed choice of the information technology professional for many years. When it comes to stability, scalability and openness there is no competition to UNIX. However, the lack of an easy to use contemporary desktop environment for UNIX has prevented UNIX from finding its way onto the desktops of the typical computer user in offices and homes.

UNIX dominates the server market and is the preferred computing platform for computing professional and scientists. Without UNIX the internet would not be. But UNIX did not address the needs of the average computer user.

This fact is particularly unfortunate since a number of implementations of UNIX (Debian GNU/Linux, FreeBSD, NetBSD etc.) are freely available on the internet. All of which are of exceptional quality and stability.

KDE The Desktop Environment

With KDE there is now an easy to use contemporary desktop environment available for UNIX. Together with a free implementation of UNIX such as GNU/Linux, UNIX/KDE constitutes a completely free and open computing platform available to anyone free of charge including its source code for anyone to modify. While there will always be room for improvement we believe to have delivered a viable alternative to some of the more commonly found and commercial operating systems/desktops combinations available today. It is our hope that the combination UNIX/KDE will finally bring the same open, reliable, stable and monopoly free computing to the average computer user that scientist and computing professionals world-wide have enjoyed for years.

KDE The Application Development Framework

Authoring applications under UNIX/X11 used to be an extremely difficult and tedious process. KDE recognizes the fact that a computing platform is only as good as the amount of first class applications available to the users of that particular platform. In view of these circumstances the KDE Project has developed a first rate compound document application framework, implementing the latest advances in framework technology and thus positioning itself in direct competition to such popular development frameworks as for example Microsofts MFC/COM/ActiveX technology. KDEs KParts compound document technology enables developers to quickly create first rate applications implementing cutting edge technology.

KDE The Office Application Suite

Leveraging the KDE application development framework a great number of applications have been built for the K Desktop Environment. A selection of those applications is contained in the KDE base distribution. At this moment KDE is developing an office application suite based on KDEs KParts technology consisting of a spread-sheet, a presentation application, an organizer, a news client and more. KPresenter, KDEs presentation application was successfully used at many presentations.

msgparser project is a parser for .msg Files in Java.

msgparser is a small open source Java library that parses Outlook .msg files and provides their content using Java objects.

msgparser uses the Apache POI - POIFS library to parse the message files which use the OLE 2 Compound Document format. Thus, it is merely a convenience library that covers the details of the .msg file. The implementation is based on the information provided at fileformat.info.

Examples:

This page shows how to use the msgparser library to access to content of a .msg file.

For parsing the .msg file, a MsgParser object must be created. This parser can process .msg files stored in a file or coming from an InputStream.

MsgParser msgp = new MsgParser();
Message msg = msgp.parseMsg("mail.msg");

The resulting msg object contains all necessary information (e.g., from, to, subject).

String fromEmail = msg.getFromEmail();
String fromName = msg.getFromName();
String subject = msg.getSubject();

Attachments are stored in Attachment objects.

List atts = msg.getAttachments();
for (Attachment att : atts) {
// do something with attachment
}

An attachment is either a file (which is a FileAttachment object) or another attached .msg file (i.e, an .msg file in an .msg file) (which is a MsgAttachment object).

Antiprism project is a suite of programs for the generation, manipulation, and visualisation of polyhedra.
Make a cube
This can be done with unipoly, which can be used to make all the uniform polyhedra.
unipoly cube > cube.off
Display with
off2pov -o cube.pov cube.off
povray +a +p cube.pov
Make the dual octahedron
pol_recip is used for making duals by polar reciprocation.
To make a nice compound the radius of the sphere used for reciprocation needs to be the distance from the cube centre to the mid-point of an edge, and the sphere centre must be the centre of the cube.
unipoly has centred the cube on (0, 0, 0), which is the default centre for pol_recip. The radius can be specified using the -R option and passing two adjacent vertex index numbers of the cube. Use off2pov with the -n option to display the cube with its vertex numbers.
off2pov -x vf -n -o cube.pov cube.off
povray +a +p cube.pov
Vertices 3 and 5 are adjacent, so make the dual octahedron like this, and display it.
pol_recip -R 3,5 cube.off > oct.off
off2pov -o oct.pov oct.off
povray +a +p oct.pov
Merge the polyhedra
OFF files are merged with off_merge
off_util cube.off oct.off > cub_oct.off
Display the result.
off2pov -o cub_oct.pov cub_oct.off
povray +a +p cub_oct.pov
Use colours
To make it clearer that this is a compound of a cube and octahedron the two polyhedra could be given different colours using off_color.
Colour the cube faces red, and the octahedron faces green.
off_color -f 1,0,0 cube.off > red_cube.off
off_color -f 0,1,0 oct.off > green_oct.off
Now merge and display as before, this time making the edge and vertex elements smaller than the defaults
off_util red_cube.off green_oct.off > color_cub_oct.off
off2pov -v 0.02 -e 0.016 -o color_cub_oct.pov color_cub_oct.off
povray +a +p color_cub_oct.pov
Enhancements:
- Edge handling has been improved.
- The GLU tesselator is used for all polygon tesselation, making polygon display more consistent in export formats.
- The minimum enclosing ball is used for camera positioning, allowing better use of screen space.
- Special duals can be calculated automatically.
- There is a new program which spirals points on a sphere, and another which arranges points in rings on a sphere.

Forth Foundation Library, in short FFL is a Forth library. It gives you a collection of words written in (ANS) forth which are useful in areas such as data types, collections, interfaces, development support, and compound modules.
The modules in the library are grouped in five clusters:
- Data types - char
- Collections - single linked list
- Interfaces - crc-32
- Development - struct, unit test
- Compound - nothing yet.
Enhancements:
- This release adds four new features to the library, including an n-tree with an iterator, a SHA-256 module, and a regular expressions module.
- The library will now also run on MinForth.

KinoSearch::Docs::FileFormat Perl module contains an overview of invindex file format.

It is not necessary to understand the guts of the Lucene-derived "invindex" file format in order to use KinoSearch, but it may be helpful if you are interested in tweaking for high performance, exotic usage, or debugging and development.
On a file system, all the files in an invindex exist in one, flat directory.

Conceptually, the files have a hierarchical relationship: an invindex is made up of "segments", each of which is an independent inverted index, and each segment is made up of several subsections.

[invindex]--|
|-"segments" file
|
|-[segments]------|
|--[seg _0]--|
| |--[postings]
| |--[stored fields]
| |--[deletions]
|
|--[seg _1]--|
| |--[postings]
| |--[stored fields]
| |--[deletions]
|
|--[ ... ]---|

The "segments" file keeps a list of the segments that make up an invindex. When a new segment is being written, KinoSearch may put files into the directory, but until the segments file is updated, a Searcher reading the index wont know about them.

Each segment is an independent inverted index. All the files which belong to a given segment share a common prefix which consists of an underscore followed by 1 or more decimal digits: _0, _67, _1058. A fully optimized index has only a single segment.

In theory there are many files which make up each segment. However, when you look inside an invindex not in the process of being updated, youll probably see only the segments file and files with either a .cfs or .del extension. The .cfs file, a "compound" file which is consolidated when a segment is finalized, "contains" all the other per-segment files.

Segments are written once, and with the exception of the deletions file, are never modified once written. They are deleted when their data is written to new segments during the process of optimization.

libevnet library provides a suite of interfaces, all built around libevent [http://www.monkey.org/~provos/libevent] , useful to network daemons.
bufio.h: Non-blocking line and block buffered I/O routines, providing tail recursive behavior so callers cannot overflow their stack with multiple back-to-back I/O issues (i.e. attempting unbounded recursive I/O operations before falling into the event loop).
This feature preserves the natural way to code in an asychronous manner by safeguarding against certain types of pathological behavior and malicious attacks.
socket.h: Asychronous accept(2) and connect(2), supporting IPv4, IPv6 and Unix Domain sockets transparently. Also supports encapsulated host address lookups for "one-shot" connection handling with automatic fallback (for MX and SRV hosts).
tls.h: OpenSSL interface which plugs into the buffered I/O API in bufio.h and socket.h API.
thread.h: Threading implementation for running "blocking" routines asychronously. Run a function in a separate thread, and have the return value collected and passed back asynchronously to the original caller.
lookup.h: Comprehensive DNS resolver with a dead simple interface. Supports PTR, A, AAAA, CNAME, NS, MX, TXT, SOA and SRV records, as well as "compound queries".
A lookup of A+AAAA+SRV first queries the SRV records, sorts them, then resolves each SRV host to an A and/or AAAA host (with a configurable CNAME chaining limit). The response is a linked list of lookup structures, beginning with an SRV record, associated A/AAAA sockaddr structures, the next SRV record, and so on. A+MX has similar behavior. This feature actually reduces network traffic, since most of the time the initial DNS query response contains all the necessary information in the additional section.
DNS SRV records are compliantly sorted according to RFC 2782 [http://rfc-ref.org/RFC-TEXTS/2782/]
Enhancements:
- The platform compatibility library was refactored.