The Streaming API for XML (StAX) is a groundbreaking new Java API for
parsing and writing XML easily and efficiently.

In essence, Beans Binding (JSR 295) is about keeping two properties
(typically of two objects) in sync. An additional emphasis is placed on
the ability to bind to Swing components, and easy integration with IDEs
such as NetBeans. This project provides the reference implementation.

Berkeley DB Java Edition is a high performance, transactional storage
engine written entirely in Java. Like the highly successful Berkeley DB
product, Berkeley DB Java Edition executes in the address space of the
application, without the overhead of client/server communication. It
stores data in the application's native format, so no runtime data
translation is required. Berkeley DB Java Edition supports full ACID
transactions and recovery. It provides an easy-to-use, programmatic
interface, allowing developers to store and retrieve information
quickly, simply and reliably.

Bean Scripting Framework (BSF) is a set of Java classes that provides
scripting language support within Java applications and access to Java
objects and methods from scripting languages. BSF allows writing JSPs
in languages other than Java while providing access to the Java class
library. In addition, BSF permits any Java application to be
implemented in part (or dynamically extended) by a language that is
embedded within it. This is achieved by providing an API that permits
calling scripting language engines from within Java as well as an
object registry that exposes Java objects to these scripting language
engines.

This BSF package currently supports several scripting languages: *
Javascript (using Rhino ECMAScript, from the Mozilla project)

* XSLT Stylesheets (as a component of Apache XML project's Xalan and
Xerces)

In addition, the following languages are supported with their own
BSF engines: * Java (using BeanShell, from the BeanShell project)

* JRuby

* JudoScript

BeanShell is a small, free, embeddable Java source interpreter with
object scripting language features written in Java. BeanShell executes
standard Java statements and expressions in addition to obvious
scripting commands and syntax. BeanShell supports scripted objects as
simple method closures like those in Perl and JavaScript(tm). You can
use BeanShell interactively for Java experimentation and debugging or
as a simple scripting engine for your applications. In short: BeanShell
is dynamically interpreted Java, plus some useful stuff. Another way to
describe it is to say that in many ways BeanShell is to Java as Tcl/Tk
is to C: BeanShell is embeddable--you can call BeanShell from your Java
applications to execute Java code dynamically at runtime or to provide
scripting extensibility for your applications. Alternatively, you can
call your Java applications and objects from BeanShell, working with
Java objects and APIs dynamically. Because BeanShell is written in Java
and runs in the same space as your application, you can freely pass
references to "real live" objects into scripts and return them as
results.

BeanShell is a small, free, embeddable, Java source interpreter with
object scripting language features, written in Java. BeanShell executes
standard Java statements and expressions, in addition to obvious
scripting commands and syntax. BeanShell supports scripted objects as
simple method closures like those in Perl and JavaScript(tm). You can
use BeanShell interactively for Java experimentation and debugging or
as a simple scripting engine for your applications. In short: BeanShell
is a dynamically interpreted Java, plus some useful stuff. Another way
to describe it is to say that in many ways BeanShell is to Java as
Tcl/Tk is to C: BeanShell is embeddable - You can call BeanShell from
your Java applications to execute Java code dynamically at run-time or
to provide scripting extensibility for your applications.
Alternatively, you can call your Java applications and objects from
BeanShell; working with Java objects and APIs dynamically. Since
BeanShell is written in Java and runs in the same space as your
application, you can freely pass references to "real live" objects into
scripts and return them as results.

With version 2.0 BeanShell becomes a fully Java compatible scripting
language. BeanShell is now capable of interpreting ordinary Java source
and loading .java source files from the class path. BeanShell scripted
classes are fully typed and appear to outside Java code and via
reflective inspection as ordinary classes. However their implementation
is fully dynamic and they may include arbitrary BeanShell scripts in
their bodies, methods, and constructors. Users may now freely mix
loose, unstructured BeanShell scripts, method closures, and full
scripted classes.

BYACC/J is an extension of the Berkeley v 1.8 YACC-compatible parser
generator. Standard YACC takes a YACC source file, and generates one or
more C files from it, which if compiled properly, will produce a
LALR-grammar parser. This is useful for expression parsing, interactive
command parsing, and file reading. Many megabytes of YACC code have
been written over the years. This is the standard YACC tool that is in
use every day to produce C/C++ parsers. I have added a "-J" flag which
will cause BYACC to generate Java source code, instead. So there
finally is a YACC for Java now!

A small java library for manipulating lists of bytes.

Castor is an open source data binding framework for Java. It is
basically the shortest path between Java objects, XML documents, and
SQL tables. Castor provides Java to XML binding, Java to SQL
persistence, and more.

cglib is a powerful, high performance and quality Code Generation
Library, It is used to extend JAVA classes and implements interfaces at
runtime.

NOTE: To use the Aspectwerks hook (net.sf.cglib.transform.hook.*), make
sure aspectwerks.jar is in the Classpath (from the 'aspectwerks' RPM)
NOTE: If you use the cglib.jar you may need to add asm.jar to your
ClassPath (from the 'asm' RPM). The cglib-nodep.jar includes the ASM
classes already.

GNU JavaMail is a free implementation of the JavaMail API
specification, version 1.3. All the code has been written from scratch
without reference to Sun's code, which allows GNU JavaMail to be used
on a completely free operating system such as GNU/Linux or the Hurd.
The code is optimized to work with free Java implementations, nothing
prevents it from being used with any compliant JVM. GNU JavaMail
provides a protocol-independent framework for building mail client
applications in Java. The API itself provides a complete MIME
implementation, and drivers for individual messaging protocols, known
as providers, can be plugged into the JavaMail framework dynamically.
Several providers, implementing Internet standard protocols, are
included with GNU JavaMail. These include: SMTP IMAP POP3 NNTP
including posting to news servers The UNIX mbox format Dan Bernstein's
Maildir format All these providers are feature-complete, and provide
cryptographically secure access where relevant.

Classworlds is a framework for container developers
who require complex manipulation of Java's ClassLoaders.
Java's native ClassLoader mechanims and classes can cause
much headache and confusion for certain types of
application developers. Projects which involve dynamic
loading of components or otherwise represent a 'container'
can benefit from the classloading control provided by
classworlds.

Cobertura is a free Java tool that calculates the percentage of code
accessed by tests. It can be used to identify which parts of your
Java program are lacking test coverage. It is based on jcoverage.

Features

* Can be executed from ant or from the command line.
* Instruments Java bytecode after it has been compiled.
* Can generate reports in HTML or XML.
* Shows percent of lines coveraged and branches coveraged for each
class, package, and for the overall project.
* Shows the McCabe cyclomatic code complexity of each class, and
the average cyclomatic code complexity for each package, and for
the overall product.
* Can sort HTML results by class name, percent of lines covered,
percent of branches covered, etc. And can sort in ascending or
decending order.

This package provides standardized, efficient versions of utility
classes commonly encountered in concurrent Java programming. This code
consists of implementations of ideas that have been around for ages and
is merely intended to save you the trouble of coding them. Discussions
of the rationale and application of several of these classes can be
found in the second edition of Concurrent Programming in Java.

Crimson is a Java XML parser which supports XML 1.0 via the
following APIs: - Java API for XML Processing (JAXP) 1.1 minus
the javax.xml.transform package. JAXP is a pluggable API that
allows applications to access XML documents in a
parser-independent manner. It endorses the industry standard SAX
and DOM APIs and also adds a few classes under the
javax.xml.parsers package to implement pluggability and utility
methods Note: the javax.xml.transform package hierarchy of JAXP
is not implemented by Crimson. One implementation of
javax.xml.transform can be found at Xalan Java 2.

- SAX 2.0

- SAX2 Extensions version 1.0

- DOM Level 2 Core Recommendation

Cryptix 3 is a cleanroom implementation of Sun's Java Cryptography
Extensions (JCE) version 1.1. In addition to that, it contains the
Cryptix Provider, which delivers a wide range of algorithms and support
for PGP 2.x. Cryptix 3 runs on both JDK 1.1 and JDK 1.2 (Java 2).

Java asn1 implementation for Cryptix.

CVSps is a program for generating 'patchset' information from a CVS
repository. In this case, a patchset is defined as a set of changes
made to a collection of files, all committed at the same time (using a
single 'cvs commit' command). This information is valuable for seeing
the big picture of the evolution of a CVS project. While CVS tracks
revision information, it is often difficult to see what changes were
'atomically' committed to the repository.

D-Haven Event is a library designed to make it easier to develop event
based processing systems. It also includes a CommandManager to handle
certain activities behind the scenes in a controlled number of
background threads. The library has been fully tested, and all
dependencies have been brought to a minimum.

D-Haven Managed Pool is a library designed to provide pools that are
asynchronously managed in a background thread. The pool system is very
flexible and can accommodate just about every need. It boasts the
ability to add pool listeners so that you can instrument and intercept
the pooled objects when they are created, destroyed, acquired, and
released.

The DOM Test Suites (DOM TS) will consist of a number of tests for each
level of the DOM specification. The tests will be represented in an XML
grammar which ensures that tests can easily be ported from the
description format to a number of specific language bindings. This
grammar will be specified in XML Schema and DTD form. The grammar will
be automatically generated from the DOM specifications themselves, to
ensure stability and correctness.

A jarjard version of dom4j that moves the classes to the
org.jboss.dom4j package space and strips the following packages:

org.dom4j.jaxb.* org.dom4j.swing.* org.dom4j.xpath.* org.dom4j.xpp.*

Eclipse Compiler for Java

The standard, old Unix line editor.

EMMA is an open-source toolkit for measuring and reporting Java code
coverage. EMMA distinguishes itself from other tools by going after a
unique feature combination: support for large-scale enterprise software
development while keeping individual developer's work fast and
iterative.