This package contains the data files for the m17n library. m17n-lib
currently supports input of more than 60 languages with more than 150
language specific input methods.
m17n-db now incorporates a set of user-contributed input methods,
formerly known as m17n-contrib.
The package also provides the tbl2mim.awk script for conversion of keyboard
files used by table based IMEngines of SCIM/IBus into m17n-lib's .mim
format.
The documentation is available through devel/m17n-docs.
This module is part of the GNOME C++ bindings effort <http://www.gtkmm.org/>.
The mm-common module provides the build infrastructure and utilities
shared among the GNOME C++ binding libraries. It is only a required
dependency for building the C++ bindings from the gnome.org version
control repository. An installation of mm-common is not required for
building tarball releases, unless configured to use maintainer-mode.
Release archives of mm-common include the Doxygen tag file for the
GNU C++ Library reference documentation. It is covered by the same
licence as the source code it was extracted from. More information
is available at <http://gcc.gnu.org/onlinedocs/libstdc++/>.
Cppo is an equivalent of the C preprocessor targeted at the OCaml language
The main purpose of cppo is to provide a lightweight tool for simple
macro substitution (#define) and file inclusion (#include) for the
occasional case when this is useful in OCaml. Processing specific
sections of files by calling external programs is also possible via
#ext directives.
The implementation of cppo relies on the standard library of OCaml and
on the standard parsing tools Ocamllex and Ocamlyacc, which contribute
to the robustness of cppo across OCaml versions.
This library contains functionality for parsing and pretty-printing
S-expressions. In addition to that it contains an extremely useful
preprocessing module for Camlp4, which can be used to automatically
generate code from type definitions for efficiently converting
OCaml-values to S-expressions and vice versa. In combination with the
parsing and pretty-printing functionality this frees the user from
having to write his own I/O-routines for data structures he defines.
Possible errors during automatic conversions from S-expressions to
OCaml-values are reported in a very human-readable way. Another module
in the library allows you to extract and replace sub-expressions in
S-expressions.
Open BEAGLE is a C++ Evolutionary Computation (EC) framework. It provides an
high-level software environment to do any kind of EC, with support for
tree-based genetic programming, bit string and real-valued genetic algorithms,
and evolution strategy.
The Open BEAGLE architecture follows strong principles of object oriented
programming, where abstractions are represented by loosely coupled objects and
where it is common and easy to reuse code. Open BEAGLE is designed to provide
an EC environment that is generic, user friendly, portable, efficient, robust,
elegant and free.
This module generates accessors for your class in the same spirit as
Class::Accessor does. While the latter deals with accessors for scalar values,
this module provides accessor makers for arrays, hashes, integers, booleans,
sets and more.
As seen in the synopsis, you can chain calls to the accessor makers. Also,
because this module inherits from Class::Accessor, you can put a call to one of
its accessor makers at the end of the chain.
The accessor generators also generate documentation ready to be used with
Sub::Documentation.
This class facilitates building frameworks of several classes that
inter-operate. It was first designed and built for "HTML::Mason", in
which the Compiler, Lexer, Interpreter, Resolver, Component, Buffer,
and several other objects must create each other transparently,
passing the appropriate parameters to the right class, possibly
substituting their own subclass for any of these objects.
The main features of "Class::Container" are:
* Declaration of parameters used by each member in a class framework
* Transparent passing of constructor parameters to the class that
needs them
* Ability to create one (automatic) or many (manual) contained
objects automatically and transparently
This is a simple, safe and streamlined toolkit for building inside-out
objects. Unlike most other inside-out object building modules already
on CPAN, this module aims for minimalism and robustness:
* Does not require derived classes to subclass it
* Uses no source filters, attributes or CHECK blocks
* Supports any underlying object type including foreign inheritance
* Does not leak memory on object destruction
* Overloading-safe
* Thread-safe for Perl 5.8 or better
* mod_perl compatible
* Makes no assumption about inheritance or initializer needs
It provides the minimal support necessary for creating safe inside-out
objects and generating flexible accessors.
Most programmers who use Perl's object-oriented features construct their
objects by blessing a hash. But, in doing so, they undermine the
robustness of the OO approach. Hash-based objects are unencapsulated:
their entries are open for the world to access and modify.
Objects without effective encapsulation are vulnerable. Instead of
politely respecting their public interface, some clever client coder
inevitably will realize that it's marginally faster to interact directly
with the underlying implementation, pulling out attribute values
directly from the hash of an object.
Config::Tiny is a perl class to read and write .ini style configuration
files with as little code as possible, reducing load time and memory
overhead. Memory usage is normally scoffed at in Perl, but in my
opinion should be at least kept in mind.
This module is primarily for reading human written files, and anything
we write shouldn't need to have documentation/comments. If you need
something with more power, move up to Config::Simple, Config::General or
one of the many other Config:: modules.