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. +
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 a simple command line interface to act as
a shell for Felix. +
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 provides a collection of utility classes used by
others components of Apache Felix. +
The Apache HTTP Server is a powerful and flexible HTTP/1.1 compliant web server. Originally designed as a replacement for the NCSA HTTP Server, it has grown to be the most popular web server on the Internet.
It features support for HTTPS, virtual hosting, CGI, SSI, IPv6, easy scripting and database integration, request/response filtering, many flexible authentication schemes, and more. +
HttpCore is a set of low level HTTP transport components that can
be used to build custom client and server side HTTP services with
a minimal footprint. HttpCore supports two I/O models:
- blocking I/O model, based on the classic Java I/O; - non-
blocking, event driven I/O model based on Java NIO.
The blocking I/O model may be more appropriate for data
intensive, low latency scenarios, whereas the non-blocking model
may be more appropriate for high latency scenarios where raw data
throughput is less important than the ability to handle thousands
of simultaneous HTTP connections in a resource efficient manner. +
http-icons date back to Mosaic for X and have been included in
the NCSA httpd and Apache server distributions. Modernized,
maintaining the original size so they can be used as a drop in
replacement. +
Apache Jackrabbit is an implementation of the Content Repository for Java Technology API, version 2.0 (JCR 2.0) as specified in the Java Specification Request 283 (JSR 283). +
log4j is a tool to help the programmer output log statements to a
variety of output targets.
It is possible to enable logging at runtime without modifying the
application binary. The log4j package is designed so that log
statements can remain in shipped code without incurring a high
performance cost.
One of the distinctive features of log4j is the notion of
hierarchical loggers. Using loggers it is possible to selectively
control which log statements are output at arbitrary granularity.
Log4j can output to: a file, a rolling file, a database with a
JDBC driver, many output asynchronously, a JMS Topic, a swing
based logging console, the NT event log, /dev/null, a SMTP server
(using javamail), a socket server, syslog, telnet daemon and
stdout.
The format of the output can be defined using one of the various
layout (or user defined layout) like: simple text, html, date,
pattern defined and XML. +
Apache Log4j 2 is an upgrade to Log4j that provides significant
improvements over its predecessor, Log4j 1.x:
API Separation: The API for Log4j is separate from the
implementation making it clear for application developers which
classes and methods they can use while ensuring forward
compatibility.
Improved Performance: Log4j 2 contains next-generation
Asynchronous Loggers based on the LMAX Disruptor library. In
multi-threaded scenarios Asynchronous Loggers have 10 times
higher throughput and orders of magnitude lower latency than
Log4j 1.x.
Support for multiple APIs: While the Log4j 2 API will provide the
best performance, Log4j 2 provides support for the SLF4J and
Commons Logging APIs.
Automatic Reloading of Configurations: Log4j 2 can automatically
reload its configuration upon modification. It will do so without
losing log events while reconfiguration is taking place.
Advanced Filtering: Log4j 2 supports filtering based on context
data, markers, regular expressions, and other components in the
Log event. Filtering can be specified to apply to all events
before being passed to Loggers or as they pass through Appenders.
Plugin Architecture: Log4j uses the plugin pattern to configure
components. As such, no code is needed to create and configure an
Appender, Layout, Pattern Converter, and so on. Log4j
automatically recognizes plugins and uses them when a
configuration references them.
Property Support: Properties can be referenced in a
configuration, Log4j will directly replace them, or Log4j will
pass them to an underlying component that will dynamically
resolve them. Properties come from values defined in the
configuration file, system properties, environment variables, the
ThreadContext Map, and data present in the event. +
Apache MINA is a network application framework which helps users
develop high performance and high scalability network
applications easily. It provides an abstract - event-driven -
asynchronous API over various transports such as TCP/IP and
UDP/IP via Java NIO.
Some of the features of Apache Mina are: - Unified API for
various transport types: TCP/UDP/RS232/In-VM - Filter interface
as an extension point; similar to Servlet filters - Low-level
and high-level API - Highly customizable thread model - Out-of-
the-box SSL / TLS and StartTLS support using Java 5 SSLEngine -
Overload shielding & traffic throttling - Unit testability using
mock objects - JMX managability - Stream-based I/O support via
StreamIoHandler
This package contains Apache Mina 2.X release. +
Openmeetings provides video conferencing, instant messaging, white board, collaborative document editing and other groupware tools. It uses API functions of Media Server for Remoting and Streaming (Red5 or Kurento). +
Apache POI provides a Java API for manipulating various file
formats based upon the Office Open XML standards (OOXML) and
Microsoft's OLE 2 Compound Document format (OLE2).
Apache POI supports the following formats: * Word (DOC, DOCX) *
Excel (XLS, XLSX) * PowerPoint (PPT, PPTX) * Visio (VSD) *
Publisher (PUB) * Outlook * TNEF (Transport Neutral Encoding
Format) +
Apache Rivet is a system for creating dynamic web content via the
Tcl programming language integrated with Apache Web Server. It is
designed to be fast, powerful and extensible, consume few system
resources, be easy to learn, and to provide the user with a
platform that can also be used for other programming tasks
outside the web (GUI's, system administration tasks, text
processing, database manipulation, XML, and so on). In order to
meet these goals Tcl programming language was chosen to combine
with the Apache HTTP Server. +
Apache::Session is a persistence framework designed to provide session management to web developers. It is intended to work with Apache and mod_perl, but it does not depend on them and will work with any web server. This module provides a set of classes that give the developer maximum functionality. Session data can be stored in a database, flat files, or shared memory. +
Apache::Session::Browseable provides some class methods to
manipulate all sessions and add the capability to index some
fields to make research faster.
This module is recommended as session backend for LemonLDAP::NG. +
Apache::Session makes maintaining user data across HTTP requests
simple.
Apache::Session::LDAP is an implementation of Apache::Session
that uses an LDAP directory to store datas. +
Apache Shiro is a powerful and flexible ??open-source?? security
framework that cleanly handles authentication, authorization,
enterprise session management, single sign-on and cryptography
services. +
This package contains the [[Maven]] metadata shared between all Apache Software Foundation's projects. +
The Apache Tika toolkit detects and extracts metadata and text
content from various documents (PPT, CSV, PDF, MP3, HTML and
more) using existing parser libraries. Tika unifies these parsers
under a single interface to allow you to easily parse over a
thousand different file types. Tika is useful for search engine
indexing, content analysis, translation, and much more. +
Tomcat can use the Apache Portable Runtime to provide superior
scalability, performance, and better integration with native
server technologies. The Apache Portable Runtime is a highly
portable library that is at the heart of Apache HTTP Server 2.x.
APR has many uses, including access to advanced IO functionality
(such as sendfile, epoll and OpenSSL), OS level functionality
(random number generation, system status, etc), and native
process handling (shared memory, NT pipes and Unix sockets).
These features allows making Tomcat a general purpose webserver,
will enable much better integration with other native web
technologies, and overall make Java much more viable as a full
fledged webserver platform rather than simply a backend focused
technology. +
Apache UIMA is an implementation of the OASIS-UIMA
specifications.
OASIS UIMA Committee: <http://www.oasis-
open.org/committees/uima/>.
Unstructured Information Management applications are software
systems that analyze large volumes of unstructured information in
order to discover knowledge that is relevant to an end user.
An example UIM application might ingest plain text and identify
entities, such as persons, places, organizations; or relations,
such as works-for or located-at.
UIMA Addons is a collection of Annotators extracted for sandbox
for official distribution. It also provide Simple Server and Pear
packaging tools. +
Apache UIMA is an implementation of the OASIS-UIMA
specifications.
OASIS UIMA Committee: <http://www.oasis-
open.org/committees/uima/>.
Unstructured Information Management applications are software
systems that analyze large volumes of unstructured information in
order to discover knowledge that is relevant to an end user.
An example UIM application might ingest plain text and identify
entities, such as persons, places, organizations; or relations,
such as works-for or located-at.
UIMA Asynch Scaleout (or UIMA AS) is an extension to the Apache
UIMA framework and SDK, using JMS messaging to support scaleout. +
<div style="background-color: #fbfcff; border: red 2px solid; padding: 10px;"><div style="text-align: center"><span style="font-size: 250%;">⚠</span> <strong style="color: red; font-size: 150%;">Retired, fork needed! comment</strong></div><br />The Wave project retired on 2018-01-15</div>
Apache Wave was a software framework for real-time collaborative editing online. +
Apache XML Security for C++ is a library for the XML Digital
Security specification. It provides processing and handling of
XML Key Management Specifications (XKMS) messages.
This package contains the files necessary for running
applications that use the Apache XML Security for C++ library. +
ZooKeeper is a centralized, reliable, service for maintaining
configuration information, naming, providing distributed
synchronization, and group services. All of these kinds of
services are used in some form or another by distributed
applications.
This package contains the shell scripts and an example
configuration but does not automatically start up the service.
The example configuration is installed with the update-
alternatives mechanism. +
Apache::ASP provides an Active Server Pages port to the Apache
Web Server with perl as the host scripting language. Active
Server Pages is a web application platform that originated with
the Microsoft NT/IIS server. Under Apache for Unix and Win32
platforms it allows a developer to create dynamic web
applications with session management and embedded perl code.
This module works under the Apache Web Server with the mod_perl
module enabled. See http://www.apache.org and
http://perl.apache.org for further information. It can also work
under a standard CGI call interface using the asp-perl command.
See README.Debian in this package for more details.
This is a portable solution, similar to ActiveState's PerlScript
for NT/IIS ASP. Work has been done and will continue to make
ports to and from this implementation as smooth as possible. +
This module is for mod_perl version 2. If you are running
mod_perl version 1, you should be using Apache::AuthCookie
instead.
Apache2::AuthCookie allows you to intercept a user's first
unauthenticated access to a protected document. The user will be
presented with a custom form where they can enter authentication
credentials. The credentials are posted to the server where
AuthCookie verifies them and returns a session key.
The session key is returned to the user's browser as a cookie. As
a cookie, the browser will pass the session key on every
subsequent accesses. AuthCookie will verify the session key and
re-authenticate the user. +
Apache::AuthenHook offers access to the 2.1 Apache authentication
API in Perl. This is different than the authentication API from
Apache 1.3 or even Apache 2.0, but in its differences lies
strength. +
After you have authenticated a user (perhaps with
Apache::AuthNetLDAP ;) you can use Apache::AuthzNetLDAP to
determine whether they are authorized to access the Web resource
under this modules control.
You can control authorization via one of four methods. The first
two are the pretty standard user and valid-user require, the
second two are group or ldap-url which are unique to LDAP. +
Perl ships with a very useful interactive debugger, however, it
does not run "out-of-the-box" in the Apache/mod_perl environment.
Apache::DB makes a few adjustments so the two will cooperate. +
Apache::LogFormat::Compiler is a module to speed up and simplify
the generation of access.log-style lines by pre-compiling the
desired log format string on object instantiation. It supports a
subset of Apache's LogFormat templates. +
Apache2::Reload reloads modules that change on the disk.
When Perl pulls a file via "require", it stores the filename in
the global hash %INC. The next time Perl tries to "require" the
same file, it sees the file in %INC and does not reload from
disk. This module's handler can be configured to iterate over the
modules in %INC and reload those that have changed on disk. It
can also monitor only specific modules that have registered
themselves with Apache2::Reload. It is possible to trigger the
check only when a special touch-file has been modified,
minimizing the number of stat() calls per request. +
Apache::Session makes maintaining user data across HTTP requests
simple. It's usable from both mod_perl scripts and more
traditional Perl CGI scripts. +
Apache::Singleton is a Perl module that provides a Singleton
class suitable for use with mod_perl.
A Singleton describes an object class that can have only one
instance in any system. An example of a Singleton might be a
print spooler or system registry.
For a description and discussion of the Singleton class, see
"Design Patterns", Gamma et al, Addison-Wesley, 1995, ISBN
0-201-63361-2. +
mime4j provides a parser, MimeStreamParser, for e-mail message
streams in plain rfc822 and MIME format. The parser uses a
callback mechanism to report parsing events such as the start of
an entity header, the start of a body, etc. If you are familiar
with the SAX XML parser interface you should have no problem
getting started with mime4j. +
mod_upload_progress enables monitoring the status of HTTP file
uploads.
Website authors can then query the server using Javascript to
provide better feedback (e.g. progress bar, throughput) while the
browser is uploading.
This module produces output similar to the equivalent modules for
other webservers. +
This module allows you to limit bandwidth usage on every virtual
host or directory or to restrict the number of simultaneous
connections.
The bandwidth control, for example, can be configured according
to the criteria: origin of the connection, file extension, file
size or user agent of the client. +
Apache2::AuthCASSimple is an authentication module for
Apache2/mod_perl2.
It allows you to authenticate users through a Yale CAS server. It
means you don't need to give login/password if you've already
authenticated with the CAS server: only tickets are exchanged
between Web client, Apache2 server and CAS server. If you are not
authenticated yet, you will be redirected to the CAS server login
form. +
The purpose of the Apache2::AuthenNTLM module is to perform a
user authentication via Microsoft's NTLM protocol. This protocol
is supported by all versions of the Internet Explorer and is
mainly useful for intranets. Depending on your preferences
setting IE will supply your windows logon credentials to the web
server when the server asks for NTLM authentication. This saves
the user to type in his/her password again.
The NTLM protocol performs a challenge/response to exchange a
random number (nonce) and get back a md4 hash, which is built
from the user's password and the nonce. This makes sure that no
password goes over the wire in plain text.
The main advantage of the Perl implementation is, that it can be
easily extended to verify the user/password against other sources
than a windows domain controller.
The default implementation is to go to the domain controller for
the given domain and verify the user. If you want to verify the
user against another source, you can inherit from
Apache2::AuthenNTLM and override it's methods. +
Apache2::SiteControl is a set of perl object-oriented classes
that implement a fine-grained security control system for a web-
based application. The intent is to provide a clear, easy-to-
integrate system that does not require the policies to be written
into your application components. It attempts to separate the
concerns of how to show and manipulate data from the concerns of
who is allowed to view and manipulate data and why.
For example, say your web application is written in HTML::Mason.
Your individual "screens" are composed of Mason modules, and you
would like to keep those as clean as possible, but decisions have
to be made about what to allow as the component is processed.
SiteControl attempts to make that as easy as possible. +
'''APEL''' stands for "A Portable Emacs Library" and contains these modules:
=== apel ===
* alist: utility for Association-list
* calist: utility for condition tree and condition/situation-alist
* filename: utility to make file-name
* install: utility to install emacs-lisp package
* mule-caeser: ROT 13-47-48 Caesar rotation utility
* path-util: utility for path management or file detection
===emu===
* broken: provide information of broken facilities of Emacs.
* invisible: provide features about invisible region
* mcharset: provide MIME charset related features
* pces: provide portable character encoding scheme features
* pccl: utility to write portable CCL program
* pcustom: provide portable custom environment
* poe: emulation module for basic functions and special forms/macros
* poem: provide basic functions to write portable MULE programs
* static: utility for static evaluation
=== Note ===
This package is a variant of APEL. The most remarkable feature is that it uses lexical binding and supports only Emacs 24.5 and later. See Wikidata for details of original APEL. +
Apertium is a machine translation platform. Data for a language pair can be used to translate text in various formats from one language to another. +
'apf' (active port forwarder) uses SSL for secure packet tunneling. It is meant for users without an external IP who want to make some services available on the Internet. afserver is placed on the machine with a publicly accessible address. afclient is then placed on the machine behind a firewall or masquerade, which makes the second machine visible to the Internet. You do not need root privileges to run afserver, nor does it use other processes. It uses 'zlib' to compress the transferred data. +
ApiGen is the tool for creating professional API documentation
from PHP source code, similar to discontinued
phpDocumentor/phpDoc. ApiGen has support for PHP 5.3 namespaces,
packages, linking between documentation, cross referencing to PHP
standard classes and general documentation, creation of
highlighted source code and experimental support for PHP 5.4
traits. +
APing is the advanced ping program written in Python from scratch that can execute four type of ICMP probes :
* echo request
* address mask request
* timestamp request
* and information request
You can also change the TOS value in packets, retrieve the UTC time from a valid timestamp reply packet, or to change the TTL, even to trace the sent packets to understand better what's going on. +
GNU APL is an interpreter for APL as described in ISO standard 13751, aka. "Programming Language APL, Extended".
This [[free software|free]] version of the programming language APL has already implemented the latest and greatest features (nested arrays and related functions, complex numbers, shared variables) and is intended to be a full implementation of the standard.
GNU APL has [https://github.com/lokedhs/gnu-apl-mode builtin support] for [[Emacs]] (''gnu-apl-mode'').
GNU APL has a predefined keyboard layout in order to produce APL characters when the "Alt" key is held down. The layout can be customized by the program [[xmodmap]] and a new keyboard mapping table like "apl.xmodmap" provided in source:
xmodmap apl.xmodmap
Text files beginning with ''#!apl'' run the interpreter as a shell with the subsequent lines as input. +
Aplakons allows you to build a sheets schema to organize activities to be followed by registered users. You can configure sets of sheets to customize each one’s activities to follow. You prepare a repository of sheets (as concrete activities), and after you order them in different arrays. The arrays can be assigned to users as activity plans. For example, a whole diet (array) based on cooking recipes (activities). +
This package provides a command line tool for converting images
from Animated PNG to animated GIF format.
The Animated Portable Network Graphics (APNG) file format is an
extension to the Portable Network Graphics (PNG) specification.
It allows for animated PNG files that work similarly to animated
GIF files, while retaining backward compatibility with non-
animated PNG files and adding support for 8-bit transparency and
24-bit images. +
Extract invividual PNG files from animated PNG.
The Animated Portable Network Graphics (APNG) file format is an
extension to the Portable Network Graphics (PNG) specification.
It allows for animated PNG files that work similarly to animated
GIF files, while retaining backward compatibility with non-
animated PNG files and adding support for 8-bit transparency and
24-bit images. +
'Apophenia' is a statistical library for C. It provides functions on the same level as those of the typical stats package (OLS, probit, singular value decomposition, &c.) but doesn't tie the user to an ad hoc language or environment. It uses the GNU Scientific Library for number crunching and SQLite for data management, so the library itself focuses on model estimation and quickly processing data. +
'App' is a C++ preprocessor for that accepts as input arbitrary C++ code that may contain embedded constructs for specifying algebraic data types and associated pattern matching operations, and produces as output the same code with all such constructs translated to normal C++. 'app' provides for C++ the same capabilities that functional languages have regarding algebraic types. 'Applib' is the associated runtime library that supports the core run time requirements of the translated code, and which provides additional utilities. +
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.