This plugin checks for software updates on systems that use package
management systems based on the zypper command found in openSUSE.

It checks for security, recommended and optional patches and also for
optional package updates.

You can define the status by patch category. Use a commata to list more
than one category to a state.

If you like to know the names of available patches and packages, use
the "-v" option.

Newt is a programming library for color text-mode, widget-based user
interfaces. Newt can be used to add stacked windows, entry widgets,
checkboxes, radio buttons, labels, plain text fields, scrollbars, etc.,
to text mode user interfaces.

This package also contains a Dialog replacement called whiptail. Newt
is based on the slang library.

Perl extension to generate and test check digits

aliased is simple in concept but is a rather handy module. It loads the class
you specify and exports into your namespace a subroutine that returns the class
name. You can explicitly alias the class to another name or, if you prefer, you
can do so implicitly. In the latter case, the name of the subroutine is the
last part of the class name.

This module is useful if you prefer a shorter name for a class. It's also handy
if a class has been renamed.

Author:
-------
Curtis Poe, ovid [at] cpan [dot] org

Though we recommend that people generally use the Moose manpage, we accept
that Moose cannot yet be used for everything everywhere. People generally
like the Moose sugar, so many people use the Mouse manpage, a lightweight
replacement for parts of Moose.

Because Mouse strives for compatibility with Moose, it's easy to substitute
one for the other. This module facilitates that substitution. By default,
Mouse will be provided to libraries, unless Moose is already loaded -or-
explicitly requested by the end-user. The end-user can force the decision
of which backend to use by setting the environment variable 'ANY_MOOSE' to
be 'Moose' or 'Mouse'.

Note that the decision of which backend to use is made only once, so that
if Any-Moose picks Mouse, then a third-party library loads Moose, anything
else that uses Any-Moose will continue to pick Mouse.

So, if you have to use the Mouse manpage, please be considerate to the
Moose fanboys (like myself!) and use the Any-Moose manpage instead. ':)'

This modules handles International Standard Book Numbers, including ISBN-10
and ISBN-13.

This data is current as of the date in the module version. At that time,
the publisher codes 9990000-9999999 or 999000-999999 had not been fixed,
although they had been proposed. I do not include them in the data. Some
regions, including India (93), Gabon (99902), and Congo (99951) have
country codes but no publisher codes. They still have entries even though
you won't be able to validate any ISBNs assigned in those regions.

Business::ISBN uses this "data pack" to do its work. You can update
Business::ISBN::Data independently of the main module as the various
ISBN organizations assign new publisher codes. The ISBN agency lists
these data at http://www.isbn-international.org/converter/ranges.htm .

CGI::Simple provides a relatively lightweight drop in replacement for
CGI.pm. It shares an identical OO interface to CGI.pm for parameter
parsing, file upload, cookie handling and header generation. This module is
entirely object oriented, however a complete functional interface is
available by using the CGI::Simple::Standard module.

Essentially everything in CGI.pm that relates to the CGI (not HTML) side of
things is available. There are even a few new methods and additions to old
ones! If you are interested in what has gone on under the hood see the
Compatibility with CGI.pm section at the end.

In practical testing this module loads and runs about twice as fast as
CGI.pm depending on the precise task.

The Class::Adapter class is intended as an abstract base class for creating
any sort of class or object that follows the Adapter pattern.

This module exports a method that is useful for factory classes.

Method modifiers are a powerful feature from the CLOS (Common Lisp Object
System) world.

'Class::Method::Modifiers::Fast' provides three modifiers: 'before',
'around', and 'after'. 'before' and 'after' are run just before and after
the method they modify, but can not really affect that original method.
'around' is run in place of the original method, with a hook to easily call
that original method. See the 'MODIFIERS' section for more details on how
the particular modifiers work.

Class::ReturnValue is a "clever" return value object that can allow code
calling your routine to expect: a boolean value (did it fail) or a list
(what are the return values)

Reading and writing configuration files is one of the most frequent tasks of
any software design. Config::Simple is the library that helps you with it.

Config::Simple is a class representing configuration file object. It supports
several configuration file syntax and tries to identify the file syntax
automatically. Library supports parsing, updating and creating configuration
files.

Author:
-------
Sherzod B. Ruzmetov

BinHex is a format used by Macintosh for transporting Mac files safely through
electronic mail, as short-lined, 7-bit, semi-compressed data streams. This
module provides a means of converting those data streams back into binary
data.

This module provides utility functions for data and data types, including
functions for subroutines and symbol table hashes (stashes).

The implementation of this module is both Pure Perl and XS, so if you have
a C compiler, all the functions this module provides are really faster.

There are many benchmarks in the _DIST-DIR/benchmark/_ directory.

An implementation of the Mayan Long Count, Haab, and Tzolkin calendars as
defined in "Calendrical Calculations The Millennium Edition". Supplemented by
"Frequently Asked Questions about Calendars".

Author:
-------
Joshua Hoblitt

DateTime::Format::Builder creates DateTime parsers. Many string formats of
dates and times are simple and just require a basic regular expression to
extract the relevant information. Builder provides a simple way to do this
without writing reams of structural code.

Builder provides a number of methods, most of which you'll never need, or at
least rarely need. They're provided more for exposing of the module's innards
to any subclasses, or for when you need to do something slightly beyond what I
expected.

Author:
-------
Iain Truskett ,
Dave Rolsky

This module understands the formats used by MySQL for its DATE, DATETIME,
TIME, and TIMESTAMP data types. It can be used to parse these formats in
order to create DateTime objects, and it can take a DateTime object and
produce a string representing it in the MySQL format.

A unique flat-file database module, written in pure perl. True multi-level
hash/array support (unlike MLDBM, which is faked), hybrid OO / tie()
interface, cross-platform FTPable files, ACID transactions, and is quite
fast. Can handle millions of keys and unlimited levels without significant
slow-down. Written from the ground-up in pure perl -- this is NOT a
wrapper around a C-based DBM. Out-of-the-box compatibility with Unix, Mac
OS X and Windows.

Author:
-------
Rob Kinyon,
Joseph Huckaby,

The main purpose of this module is to provide an easy way to build a
profile to validate a data structure. It does this by giving you a set of
declarative keywords in the importing namespace.

Perl Convenience wrapper for the rsync(1) program. Written for rsync-2.3.2 and
updated for rsync-2.6.0 but should perform properly with most recent versions.

Author:
-------
Lee Eakin

The intent of File::ShareDir is to provide a companion to Class::Inspector and
File::HomeDir, modules that take a process that is well-known by advanced Perl
developers but gets a little tricky, and make it more available to the larger
Perl community.

Quite often you want or need your Perl module (CPAN or otherwise) to have
access to a large amount of read-only data that is stored on the file-system at
run-time.

On a linux-like system, this would be in a place such as /usr/share, however
Perl runs on a wide variety of different systems, and so the use of any one
location is unreliable.

Perl provides a little-known method for doing this, but almost nobody is aware
that it exists. As a result, module authors often go through some very strange
ways to make the data available to their code.

The most common of these is to dump the data out to an enormous Perl data
structure and save it into the module itself. The result are enormous
multi-megabyte .pm files that chew up a lot of memory needlessly.

Author:
-------
Adam Kennedy

GD::Barcode is a subclass of GD and allows you to create barcode image with GD.

This module based on "Generate Barcode Ver 1.02 By Shisei Hanai 97/08/22".

From 1.14, you can use this module even if no GD (except plot method).

Author:
-------
Kawai Takanori GCD00051@nifty.ne.jp

GnuPG::Interface and its associated modules are designed to provide an
object-oriented method for interacting with GnuPG, being able to perform
functions such as but not limited to encrypting, signing, decryption,
verification, and key-listing parsing.

How Data Member Accessor Methods are Created
Each module in the GnuPG::Interface bundle relies on Any::Moose to
generate the get/set methods used to set the object's data members.
_This is very important to realize._ This means that any data member
which is a list has special methods assigned to it for pushing,
popping, and clearing the list.

Understanding Bidirectional Communication
It is also imperative to realize that this package uses interprocess
communication methods similar to those used in the IPC::Open3 manpage
and the perlipc/"Bidirectional Communication with Another Process"
manpage, and that users of this package need to understand how to use
this method because this package does not abstract these methods for
the user greatly. This package is not designed to abstract this away
entirely (partly for security purposes), but rather to simply help
create 'proper', clean calls to GnuPG, and to implement key-listing
parsing. Please see the perlipc/"Bidirectional Communication with
Another Process" manpage to learn how to deal with these methods.

Using this package to do message processing generally invovlves
creating a GnuPG::Interface object, creating a GnuPG::Handles object,
setting some options in its *options* data member, and then calling a
method which invokes GnuPG, such as *clearsign*. One then interacts
with with the handles appropriately, as described in the
perlipc/"Bidirectional Communication with Another Process" manpage.

Under older perls this module provides a drop in compatible api to the
Hash::Util::FieldHash manpage using the perltie manpage. When the
Hash::Util::FieldHash manpage is available it will use that instead.

This way code requiring field hashes can benefit from fast, robust field
hashes on Perl 5.10 and newer, but still run on older perls that don't ship
with that module.

See the Hash::Util::FieldHash manpage for all the details of the API.