Property:Full description
A
Any::Template::ProcessDir is a module to recursively processes a
directory of templates, generating a set of result files in the
same directory or in a parallel directory. Each file in the
source directory may be template-processed, copied, or ignored
depending on its pathname. +
URI::Escape is great, but URI::Escape::XS is faster.
Any::URI::Escape loads URI::Escape::XS and imports the two most
common methods if XS is installed. +
AnyData provides simple and uniform access to data from many
sources -- perl arrays, local files, remote files retrievable via
http or ftp -- and in many formats including flat files (CSV,
Fixed Length, Tab Delimited, etc), standard format files (Web
Logs, Passwd files, etc.), structured files (XML, HTML Tables)
and binary files with parseable headers (mp3s, jpgs, pngs, etc). +
AnyEdit plugin adds several new tools to the context menu of
text-based Eclipse editors, to output consoles, to Eclipse main
menu and editor toolbar. AnyEdit contributes also Import/Export
working sets wizards.
AnyEdit can:
* show the whitespace (tabs vs. spaces) in editors and may use
custom project settings for tab <-> spaces auto-convert-on-
save feature. * perform tabs <-> spaces convert on multiple
files or entire directories and supports also file exclusion
filter for tabs <-> spaces action. * automatically remove
trailing whitespaces and/or perform tabs <-> spaces conversion
on a "save" action in all text-based Eclipse editors. It can
automatically create a new line at the end of the file if the
last line was not terminated by new line.
Also adds additional actions to menus and toolbars:
* "Save All", "Open File" and "Show whitespace in editor" buttons
to the global Eclipse toolbar. * "Open File", "Open Type" and
"Save to file..." actions to supported output consoles and
"Save to file..." toolbar button to the Console view. * four new
context menu actions to "Compare With" and "Replace With" menus
in both editors and files. +
AnyEvent is not an event model itself, it only interfaces to
whatever event model the main program happens to use, in a
pragmatic way. For event models, the statement "there can only be
one" is a bitter reality: In general, only one event loop can be
active at the same time in a process. This module cannot change
this, but it can hide the differences between them.
The goal of AnyEvent is to offer module authors the ability to do
event programming (waiting for I/O or timer events) without
subscribing to a religion, a way of living, and most importantly:
without forcing your module users into the same thing by forcing
them to use the same event model you use. +
AnyEvent::DBD::Pg can be used inside AnyEvent application to
access PostgreSQL database in non-blocking mode. +
The AnyEvent::HTTPD module provides a simple HTTPD for serving
simple web application interfaces. It's completelly event based
and independend from any event loop by using the AnyEvent module. +
AnyEvent::XMPP is an implementation of XMPP in Perl, formerly
know under the name Net::XMPP2, it allows you to easily write
Clients and Components. In comparsion to Net::XMPP it offers a
event based API and is independent of an event loop with
AnyEvent.
The following XEPs are implemented: * XEP-0004 - Data Forms *
XEP-0030 - Service Discovery * XEP-0054 - vcard-temp (XMPP
vCards) * XEP-0066 - Out of Band Data * XEP-0077 - In-Band
Registration * XEP-0078 - Non-SASL Authentication * XEP-0082 -
XMPP Date and Time Profiles * XEP-0086 - Error Condition
Mappings * XEP-0091 - Delayed Delivery (legacy) * XEP-0092 -
Software Version * XEP-0114 - Jabber Component Protocol *
XEP-0153 - vCard-Based Avatars * XEP-0199 - XMPP Ping *
XEP-0203 - Delayed Delivery (new) +
AnyEvent::CacheDNS provides a very simple DNS resolver that
caches its results and can improve the connection times to remote
hosts.
It's possible to register this class as AnyEvent's main DNS
resolver by passing the tag :register in the use statement.
This module is very basic and has no policies for clearing or
invalidating the DNS cache. +
AnyEvent::DBI is an AnyEvent extension, you need to make sure
that you use and run a supported event loop. This module
implements asynchronous DBI access by forking or executing
separate "DBI-Server" processes and sending them requests. It
means that you can run DBI requests in parallel to other tasks.
The overhead for very simple statements ("select 0") is somewhere
around 100% to 120% (dual/single core CPU) compared to an
explicit prepare_cached/execute/fetchrow_arrayref/finish
combination. +
AnyEvent::Gearman is a module set of client/worker modules for
Gearman for AnyEvent applications.
It provides some shortcuts for AnyEvent::Gearman::Client and
AnyEvent::Gearman::Worker. Please read these modules'
documentation for more details. +
AnyEvent::HTTP is an simple non-blocking HTTP/HTTPS client
implementation, which uses AnyEvent under the hood for
asynchronous I/O. It supports GET, POST and other request
methods, cookies and more. It is well suited to most HTTP tasks,
while retaining fine-grained control over request and response
headers to cater to more complex requirements. +
AnyEvent::HTTP::ScopedClient is based on the Node.js Scoped-http-
client. This module provides a simple wrapper around the
AnyEvent::HTTP for using a easy event based HTTP client in Perl. +
AnyEvent::I3 provides integration of the i3 IPC protocol into the
AnyEvent framework. Use it to have an easy way of communicating
with i3 using event-based (or blocking, if you like) programming. +
AnyEvent::IRC is a Perl module that can be conceptualized as a
toolbox for handling Internet Relay Chat (IRC) connections and
communications. It won't do everything for you, and you still
need to have a basic understanding of the internal protocol. +
AnyEvent::Memcached provides a memcached client for Perl and
AnyEvent. +
AnyEvent::Redis is a non-blocking (event-driven) Redis client
based on the AnyEvent event loop framework.
Redis is a key-value database in a similar vein to memcache but
the dataset is non-volatile. Redis additionally provides native
support for atomically manipulating and querying data structures
such as lists and sets. +
Loads whichever is the fastest JSON module installed and provides
a uniform API regardless of which JSON implementation is used.
The exceptions will also be the same whichever JSON module is
used. The ranking of the JSON implementations is based on a
benchmark. +
anymeal is a cookbook database front-end. It can handle more than 100,000 recipes, and can search recipes for a given set of ingredients. It is designed to be lean and flexible. +
anyPaper is a front-end for wallpapersetter. it let you: Preview
of selected image. Six modes of setting wallpaper (fullscreen,
normal, tiled, adjusted, scaled and custom scale). User can
select the background color, image position, wallpapersetter and
screen size. Preview of background before setting no-set option
for only handling images (command line). +
Apache ActiveMQ is a message broker built around Java Message
Service (JMS) API : allow sending messages between two or more
clients in a loosely coupled, reliable, and asynchronous way.
This message broker supports : * JMS 1.1 and J2EE 1.4 with
support for transient, persistent, transactional and XA
messaging * Spring Framework, CXF and Axis integration *
pluggable transport protocols such as in-VM, TCP, SSL, NIO, UDP,
multicast, JGroups and JXTA * persistence using JDBC along
with journaling * OpenWire (cross language wire protocol) and
Stomp (Streaming Text Orientated Messaging Protocol) protocols
This package contains a server installation of ActiveMQ. +
A system independent (i.e. not shell based) build tool that uses
XML files as "Makefiles". This package contains the scripts and
the core tasks libraries. +
The Avalon framework consists of interfaces that define
relationships between commonly used application components, best-
of-practice pattern enforcement, and several lightweight
convenience implementations of the generic components. +
Apache AxKit is an XML Application Server for Apache. It provides on-the-fly conversion from XML to any format, such as HTML, WAP or text using either W3C standard techniques, or flexible custom code. AxKit also uses a built-in Perl interpreter to provide some amazingly powerful techniques for XML transformation. +
Apache AXIS is an implementation of the SOAP ("Simple Object
Access Protocol") submission to W3C.
From the draft W3C specification:
SOAP is a lightweight protocol for exchange of information in a
decentralized, distributed environment. It is an XML based
protocol that consists of three parts: an envelope that defines a
framework for describing what is in a message and how to process
it, a set of encoding rules for expressing instances of
application-defined datatypes, and a convention for representing
remote procedure calls and responses.
This project is a follow-on to the Apache SOAP project. +
The Byte Code Engineering Library is intended to give users a
convenient possibility to analyze, create, and manipulate
(binary) Java class files (those ending with .class). Classes are
represented by objects which contain all the symbolic information
of the given class: methods, fields and byte code instructions,
in particular.
Such objects can be read from an existing file, be transformed by
a program (e.g. a class loader at run-time) and dumped to a file
again. An even more interesting application is the creation of
classes from scratch at run-time. The Byte Code Engineering
Library (BCEL) may be also useful if you want to learn about the
Java Virtual Machine (JVM) and the format of Java .class files. +
The codec package contains simple encoder and decoders for
various formats such as Base64 and Hexadecimal. In addition to
these widely used encoders and decoders, the codec package also
maintains a collection of phonetic encoding utilities.
This is a part of the Apache Commons Project. +
The Java Collections Framework was a major addition in JDK 1.2.
It added many powerful data structures that accelerate
development of most significant Java applications. Since that
time it has become the recognised standard for collection
handling in Java.
Commons Collections seek to build upon the JDK classes by
providing new interfaces, implementations and utilities. There
are many features, including:
* Bag interface for collections that have a number of copies of
each object * BidiMap interface for maps that can be looked up
from value to key as well and key to value * MapIterator
interface to provide simple and quick iteration over maps *
Transforming decorators that alter each object as it is added to
the collection * Composite collections that make multiple
collections look like one * Ordered maps and sets that retain
the order elements are added in, including an LRU based map *
Reference map that allows keys and/or values to be garbage
collected under close control * Many comparator
implementations * Many iterator implementations * Adapter
classes from array and enumerations to collections * Utilities
to test or create typical set-theory properties of collections
such as union, intersection, and closure +
The Apache Commons Compress library defines an API for working with ar, cpio, Unix dump, tar, zip, gzip, XZ, Pack200, bzip2, 7z, arj and lzma files. +
Commons Configuration provides a generic configuration interface which enables an application to read configuration data from a variety of sources:
*Properties files
*XML documents
*Windows INI files
*Property list files (.plist)
*JNDI
*JDBC Datasource
*System properties
*Applet parameters
*Servlet parameters
Additional sources of configuration parameters can be created by using custom configuration objects. +
The DBCP package provides database connection pooling services.
The following features are supported
* DataSource and Driver interfaces to the pool. * Support for
arbitrary sources of the underlying Connections. * Integration
with arbitrary org.apache.commons.pool.ObjectPool
implementations. * Support for Connection validation,
expiration, etc. * Support for PreparedStatement pooling. * XML
configuration.
This is a part of the Apache Commons Project. +
This is the native application for launching Java applications
implementing certain interfaces from the libcommons-daemon-java
package as daemons. +
Executing external processes from Java is a well-known problem
area. It is inherently platform dependent and requires the
developer to know and test for platform specific behaviors, for
example using cmd.exe on Windows or limited buffer sizes causing
deadlocks. The JRE support for this is very limited, albeit
better with the new Java SE 1.5 ProcessBuilder class.
Reliably executing external processes can also require knowledge
of the environment variables before or after the command is
executed. In J2SE 1.1-1.4 there is no support for this, since the
method, System.getenv(), for retrieving environment variables is
deprecated.
There are currently several different libraries that for their
own purposes have implemented frameworks around Runtime.exec() to
handle the various issues outlined above. The commons-exec
package aims at coordinating and learning from these initiatives
to create and maintain a simple, reusable and well-tested
package. +
The Commons FileUpload package makes it easy to add robust, high-
performance, file upload capability to your servlets and web
applications.
FileUpload parses HTTP requests which conform to RFC 1867, "Form-
based File Upload in HTML". That is, if an HTTP request is
submitted using the POST method, and with a content type of
"multipart/form-data", then FileUpload can parse that request,
and make the results available in a manner easily used by the
caller. +
JEXL is a library intended to facilitate the implementation of
dynamic and scripting features in applications and frameworks
written in Java.
JEXL implements an Expression Language based on some extensions
to the JSTL Expression Language supporting most of the constructs
seen in shell-script or ECMAScript. +
This library provides the Java developer the ability to
manipulate javabeans with the XPath syntax. It also supports Java
collections, objects with dynamic properties (like Map,
ServletContext, etc) and mechanism for adding support for
additional models.
One of the most important feature of the component is the
unification of reference syntax between DOM and Java. +
The Lang Component contains a set of Java classes that provide
helper methods for standard Java classes, especially those found
in the java.lang package in the Sun JDK. The following classes
are included:
* StringUtils - Helper for java.lang.String. * CharSetUtils -
Methods for dealing with CharSets, which are sets of
characters such as [a-z] and [abcdez]. * RandomStringUtils -
Helper for creating randomised Strings. * NumberUtils - Helper
for java.lang.Number and its subclasses. * NumberRange - A range
of numbers with an upper and lower bound. * ObjectUtils - Helper
for java.lang.Object. * SerializationUtils - Helper for
serializing Objects. * SystemUtils - Utility class defining the
Java system properties. * NestedException package - A sub-
package for the creation of nested exceptions. * Enum package
- A sub-package for the creation of enumerated types. * Builder
package - A sub-package for the creation of equals, hashCode,
compareTo and toString methods. +
Provides a simple, component oriented interface together with
wrappers for several existing java logging systems. The user can
choose at runtime which system he want to use for logging. +
Pool provides an Object-pooling API, with three major aspects:
1. A generic object pool interface that clients and implementors
can use to provide easily interchangeable pooling
implementations. 2. A toolkit for creating modular object pools.
3. Several general purpose pool implementations. +
Commons VFS provides a single API for accessing various different
file systems. It presents a uniform view of the files from
various different sources, such as the files on local disk, on an
HTTP server, or inside a Zip archive.
This is a part of the Apache Commons Project. +
The Commons Validator is a basic validation framework that lets
you define validation rules for a JavaBean in an xml file.
Validation rules can be defined in an xml file which keeps them
abstracted from JavaBean you are validating. +
This package contains the Maven metadata shared between all
components of the Apache Commons project. +
Apache CouchDB is a distributed, fault-tolerant and schema-free document-oriented database accessible via a RESTful HTTP/JSON API. Among other features, it provides robust, incremental replication with bi-directional conflict detection and resolution, and is queryable and indexable using a table-oriented view engine with JavaScript acting as the default view definition language. CouchDB is written in Erlang, but can be easily accessed from any environment that provides means to make HTTP requests. There are a multitude of third-party client libraries that make this even easier for a variety of programming languages and environments. +
The Felix project is an implementation of the OSGi R4.2 core
framework specification.
OSGi framework is a module system and service platform for the
Java programming language that implements a complete and dynamic
component model.
This subproject provide implementation of repository containing
"bundles". +
Apache Felix Gogo is a subproject of Apache Felix implementing
the OSGi RFC 147, which describes a standard shell for OSGi-based
environments.
Command bundle of Gogo subproject implements a set of basic
commands. +
Apache Felix Gogo is a subproject of Apache Felix implementing
the OSGi RFC 147, which describes a standard shell for OSGi-based
environments.
Runtime bundle of Gogo subproject implements the core command
processing functionality. +
Apache Felix Gogo is a subproject of Apache Felix implementing
the OSGi RFC 147, which describes a standard shell for OSGi-based
environments.
Shell bundle of Gogo subproject provides a simple textual user
interface to interact with the command processor. +
Maven is a software project management and comprehension tool.
Based on the concept of a project object model (POM), Maven can
manage a project's build, reporting and documentation from a
central piece of information.
This plugin allow you to handle artifact OSGi metadata of your
artifact (JAR, WAR). It manage a new type of packaging "bundle"
in your POM.
This plugin depends on Felix Bundle Repository and BND for low-
level handling of metadata. +
The goal of the Apache Felix OSGi Bundle Repository (OBR) is two-
fold: 1. To simplify deploying and using available bundles with
Felix. 2. To encourage independent bundle development so that
communities of interest can grow. +
The Felix project is an implementation of the OSGi R4.2 core
framework specification.
OSGi framework is a module system and service platform for the
Java programming language that implements a complete and dynamic
component model.
This subproject defines a shell service for creating and
executing arbitrary commands into Apache Felix. +
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the page “GNU Free Documentation License”.
The copyright and license notices on this page only apply to the text on this page. Any software or copyright-licenses or other similar notices described in this text has its own copyright notice and license, which can usually be found in the distribution or license text itself.