# packages

pkgId: b75c61ef7ea7da79a0e67a960d6f914bc3395b74
name: GeoIP
arch: src
version: 1.4.4
epoch: 0
release: 2
summary: C library for country/city/organization to IP address or hostname mapping
url: http://www.maxmind.com/app/c
rpm_license: LGPLv2+
rpm_vendor: End Point Corporation
rpm_group: Development/Libraries
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: GeoIP-1.4.4-2.src.rpm
checksum_type: sha
description:
  GeoIP is a C library that enables the user to find the country that any IP
  address or hostname originates from. It uses a file based database that is
  accurate as of March 2003. This database simply contains IP blocks as keys, and
  countries as values. This database should be more complete and accurate than
  using reverse DNS lookups.


pkgId: e47af292ce7abdd18dbd86d28d9a7cb5d98ce734
name: NetworkManager-vpnc
arch: src
version: 0.7.0.99
epoch: 1
release: 1.ep.4
summary: NetworkManager VPN plugin for vpnc
url: http://www.gnome.org/projects/NetworkManager/
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: NetworkManager-vpnc-0.7.0.99-1.ep.4.src.rpm
checksum_type: sha
description:
  This package contains software for integrating the vpnc VPN software
  with NetworkManager and the GNOME desktop


pkgId: ef5fa8d4f157cc7ab8db542ea9bda24ed7b330d7
name: alpine
arch: src
version: 2.00
epoch: 0
release: 2
summary: Alternative Pine mail user agent
url: http://www.washington.edu/alpine/
rpm_license: Apache License
rpm_vendor: End Point Corporation
rpm_group: Applications/Internet
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Dag Wieers <dag@wieers.com>
location_href: alpine-2.00-2.src.rpm
checksum_type: sha
description:
  Alpine (Alternatively Licensed Program for Internet News & Email) is a tool
  for reading, sending, and managing electronic messages. Alpine is the
  successor to Pine and was developed by Computing & Communications at the
  University of Washington.

  Though originally designed for inexperienced email users, Alpine supports
  many advanced features, and an ever-growing number of configuration and
  personal-preference options.


pkgId: ff73b015cf3b0b6c34bffffd0ece706e61bf8dc3
name: apt
arch: src
version: 0.5.15lorg3.2
epoch: 0
release: 4
summary: Debian's Advanced Packaging Tool with RPM support
url: http://apt-rpm.org/
rpm_license: GPL
rpm_vendor: End Point Corporation
rpm_group: System Environment/Base
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Dag Wieers <dag@wieers.com>
location_href: apt-0.5.15lorg3.2-4.src.rpm
checksum_type: sha
description:
  A port of Debian's apt tools for RPM based distributions, or at least
  originally for Conectiva and now Red Hat Linux. It provides the apt-get
  utility that provides a simpler, safer way to install and upgrade packages.
  APT features complete installation ordering, multiple source capability and
  several other unique features.


pkgId: 060f145913cbecc6929f61f6e6e72249fbf247fa
name: asciidoc
arch: src
version: 8.2.6
epoch: 0
release: 1.rf
summary: Tool to convert AsciiDoc text files to DocBook, HTML or Unix man pages
url: http://www.methods.co.nz/asciidoc/
rpm_license: GPL
rpm_vendor: Dag Apt Repository, http://dag.wieers.com/apt/
rpm_group: Applications/Text
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Dag Wieers <dag@wieers.com>
location_href: asciidoc-8.2.6-1.rf.src.rpm
checksum_type: sha
description:
  AsciiDoc is a text document format for writing short documents, articles,
  books and UNIX man pages. AsciiDoc files can be translated to HTML and
  DocBook markups using the asciidoc(1) command.


pkgId: 859e1cb0a1d06f890ae6e65b98605a53e3fdd03c
name: augeas
arch: src
version: 0.3.6
epoch: 0
release: 1.ep
summary: A library for changing configuration files
url: http://augeas.net/
rpm_license: LGPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: augeas-0.3.6-1.ep.src.rpm
checksum_type: sha
description:
  A library for programmatically editing configuration files. Augeas parses
  configuration files into a tree structure, which it exposes through its
  public API. Changes made through the API are written back to the initially
  read files.

  The transformation works very hard to preserve comments and formatting
  details. It is controlled by ``lens'' definitions that describe the file
  format and the transformation into a tree.


pkgId: 42f62339ad90978fb2a61cab86390cbafccdd84d
name: bacula
arch: src
version: 5.0.2
epoch: 0
release: 1
summary: Bacula - The Network Backup Solution
url: http://www.bacula.org/
rpm_license: GPL v2
rpm_vendor: The Bacula Team
rpm_group: System Environment/Daemons
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: D. Scott Barninger <barninger@fairfieldcomputers.com>
location_href: bacula-5.0.2-1.src.rpm
checksum_type: sha
description:
  Bacula - It comes by night and sucks the vital essence from your computers.

  Bacula is a set of computer programs that permit you (or the system
  administrator) to manage backup, recovery, and verification of computer
  data across a network of computers of different kinds. In technical terms,
  it is a network client/server based backup program. Bacula is relatively
  easy to use and efficient, while offering many advanced storage management
  features that make it easy to find and recover lost or damaged files.
  Bacula source code has been released under the GPL version 2 license.


pkgId: 570c3abb024bf4fb0a1bbb8a6b80e6bd37974dd7
name: bittorrent
arch: src
version: 4.4.0
epoch: 0
release: 7.ep
summary: BitTorrent swarming network file transfer tool
url: http://www.bittorrent.com/
rpm_license: BitTorrent
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Internet
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: bittorrent-4.4.0-7.ep.src.rpm
checksum_type: sha
description:
  BitTorrent is a tool for distributing files. It's extremely easy to use -
  downloads are started by clicking on hyperlinks. Whenever more than one person
  is downloading at once they send pieces of the file(s) to each other, thus
  relieving the central server's bandwidth burden. Even with many simultaneous
  downloads, the upload burden on the central server remains quite small, since
  each new downloader introduces new upload capacity.


pkgId: 041065c147bfc16491f6460678598e6629116924
name: bonnie++
arch: src
version: 1.03c
epoch: 0
release: 1
summary: Filesystem and disk benchmark & burn-in suite
url: http://www.coker.com.au/bonnie++/
rpm_license: GPLv2
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: bonnie++-1.03c-1.src.rpm
checksum_type: sha
description:
  bonnie++ filesystem and disk benchmark suite aggressively reads & writes
  in various ways on your filesystem then outputs useful benchmark performance
  data.  bonnie++ is also useful as a hardware, disk, and filesystem stability
  test, exposing some types of hardware or kernel failures that would otherwise
  be difficult to detect.

  Do not leave bonnie++ installed on a production system.  Use only while you
  test servers.


pkgId: f3eb28d5824e4e003b0be17dd361b17f6bbef4f3
name: bonnie++
arch: src
version: 1.94
epoch: 0
release: 1.ep
summary: Benchmark suite for hard drive and file system performance
url: http://www.coker.com.au/bonnie++/
rpm_license: GPL
rpm_vendor: Dag Apt Repository, http://dag.wieers.com/apt/
rpm_group: Applications/System
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Dag Wieers <dag@wieers.com>
location_href: bonnie++-1.94-1.ep.src.rpm
checksum_type: sha
description:
  Bonnie++ is a benchmark suite that is aimed at performing a number of
  simple tests of hard drive and file system performance. Then you can
  decide which test is important and decide how to compare different
  systems after running it. I have no plans to ever have it produce a
  single number, because I don't think that a single number can be useful
  when comparing such things.


pkgId: 3332e2f06ab2295fa5895b10e9b5ec109879348e
name: cabextract
arch: src
version: 0.6
epoch: 0
release: 2
summary: a program to extract Microsoft Cabinet files
url: http://www.kyz.uklinux.net/cabextract.php3
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Archiving
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: cabextract-0.6-2.src.rpm
checksum_type: sha
description:
  Cabinet (.CAB) files are a form of archive, which Microsoft use to
  distribute their software, and things like Windows Font Packs. The
  cabextract program simply unpacks such files.


pkgId: d27512c8960fd55e7a1c7d6ef248d6f619405617
name: cacti
arch: src
version: 0.8.7f
epoch: 0
release: 2.ep
summary: An rrd based graphing tool
url: http://www.cacti.net/
rpm_license: GPLv2+ and LGPLv2 and (MPLv1.1 or GPLv2 or LGPLv2) and (LGPLv2 or BSD)
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel5-build32
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: cacti-0.8.7f-2.ep.src.rpm
checksum_type: sha
description:
  Cacti is a complete frontend to RRDTool. It stores all of the
  necessary information to create graphs and populate them with
  data in a MySQL database. The frontend is completely PHP
  driven. Along with being able to maintain graphs, data
  sources, and round robin archives in a database, Cacti also
  handles the data gathering. There is SNMP support for those
  used to creating traffic graphs with MRTG.


pkgId: 69e7db03faaf0510681b8497e6f22d453b059ea9
name: cgilib
arch: src
version: 0.5
epoch: 0
release: 3..ep
summary: C interface to CGI (common gateway interface)
url: http://www.infodrom.north.de/cgilib/
rpm_license: GPL
rpm_vendor: Dag Apt Repository, http://dag.wieers.com/apt/
rpm_group: Development/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Dag Wieers <dag@wieers.com>
location_href: cgilib-0.5-3..ep.src.rpm
checksum_type: sha
description:
  cgilib is a simple library that provides an easy interface to the
  common gateway interface, known as CGI. The purpose is to provide an
  easy to use interface to CGI if you need to write your program in C
  instead of perl.


pkgId: 8d84a28f80b676a169e218e39b4200777c313a09
name: check_openmanage
arch: src
version: 3.5.2
epoch: 0
release: 1.ep
summary: Nagios plugin to monitor hardware health on Dell servers
url: http://folk.uio.no/trondham/software/check_openmanage.html
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Trond Hasle Amundsen <t.h.amundsen@usit.uio.no>
location_href: check_openmanage-3.5.2-1.ep.src.rpm
checksum_type: sha
description:
  check_openmanage is a plugin for Nagios which checks the hardware
  health of Dell servers running OpenManage Server Administrator
  (OMSA). The plugin can be used remotely with SNMP or locally with
  NRPE, check_by_ssh or similar, whichever suits your needs and
  particular taste. The plugin checks the health of the storage
  subsystem, power supplies, memory modules, temperature probes etc.,
  and gives an alert if any of the components are faulty or operate
  outside normal parameters.


pkgId: b091ae01e9d3390f7db03364247c961228167548
name: cluster-glue
arch: src
version: 1.0.3
epoch: 0
release: 1.ep
summary: Reusable cluster components
url: http://www.clusterlabs.org
rpm_license: GPLv2+ and LGPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: cluster-glue-1.0.3-1.ep.src.rpm
checksum_type: sha
description:
  A collection of common tools that are useful for writing cluster managers
  such as Pacemaker.
  Provides a local resource manager that understands the OCF and LSB
  standards, and an interface to common STONITH devices.


pkgId: 78fe0c5c207c8cfa12474961a0f52fa6c5a06e96
name: collectd
arch: src
version: 4.10.2
epoch: 0
release: 0.ep
summary: Statistics collection daemon for filling RRD files.
rpm_license: GPL
rpm_vendor: collectd development team <collectd@verplant.org>
rpm_group: System Environment/Daemons
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point <hosting@endpoint.com>
location_href: collectd-4.10.2-0.ep.src.rpm
checksum_type: sha
description:
  collectd is a small daemon which collects system information periodically and
  provides mechanisms to monitor and store the values in a variety of ways. It
  is written in C for performance. Since the daemon doesn't need to startup
  every time it wants to update the values it's very fast and easy on the
  system. Also, the statistics are very fine grained since the files are updated
  every 10 seconds.


pkgId: 4bc7b98e7452ba9574649927ee48c1d4aaacf1de
name: corosync
arch: src
version: 1.2.0
epoch: 0
release: 1.ep
summary: The Corosync Cluster Engine and Application Programming Interfaces
url: http://www.openais.org
rpm_license: BSD
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: corosync-1.2.0-1.ep.src.rpm
checksum_type: sha
description:
  This package contains the Corosync Cluster Engine Executive, several default
  APIs and libraries, default configuration files, and an init script.


pkgId: 88581796851503b02b3ace9f77c9e584c35c458b
name: cpq_cciss
arch: src
version: 3.6.18
epoch: 0
release: 17
summary: HP Smart Array Driver for 2.6 kernels
url: http://add-documentation-address-here
rpm_license: GPL
rpm_vendor: HP Computer Corporation
rpm_group: System Environment/Kernel
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Stephen Cameron <steve.cameron@hp.com>
location_href: cpq_cciss-3.6.18-17.src.rpm
checksum_type: sha
description:
  This Package includes the CCISS driver.
  This driver supports the following controllers:
  -SA5i
  -SA5i+
  -SA532
  -SA5300
  -SA5312
  -SA641
  -SA642
  -SA6400
  -SA6i


pkgId: f14189a1acc40d627bd197f34a9c4a8d6d97a493
name: cron-harness
arch: src
version: 20060102
epoch: 0
release: 1
summary: Capture program output and email it only if nonzero exit status
url: http://www.endpoint.com/
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/File
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: cron-harness-20060102-1.src.rpm
checksum_type: sha
description:
  cron-harness wraps other programs. If the progrma it runs returns an error
  exit value, it will either email its output somewhere (if the -e option is
  given) or simply send it to stdout (the default); otherwise it is silent.


pkgId: 2be2167c9ac47315285b7beb7bda767ed307e4e1
name: cvsps
arch: src
version: 2.2
epoch: 0
release: 0.1.b1
summary: Patchset tool for CVS
url: http://www.cobite.com/cvsps/
rpm_license: GPL+
rpm_vendor: End Point Corporation
rpm_group: Development/Tools
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: cvsps-2.2-0.1.b1.src.rpm
checksum_type: sha
description:
  CVSps is a program for generating 'patchset' information from a CVS
  repository.  A patchset in this case is defined as a set of changes
  made to a collection of files, and all committed at the same time
  (using a single 'cvs commit' command).  This information is valuable
  to 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 committed 'atomically' to the repository.


pkgId: c80a136cc5f8536cfbf1f0519e6e0627f3c51ab0
name: dovecot
arch: src
version: 1.2.9
epoch: 1
release: 2.ep
summary: Secure imap and pop3 server
url: http://www.dovecot.org/
rpm_license: MIT and LGPLv2 and GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Daemons
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: dovecot-1.2.9-2.ep.src.rpm
checksum_type: sha
description:
  Dovecot is an IMAP server for Linux/UNIX-like systems, written with security
  primarily in mind.  It also contains a small POP3 server.  It supports mail
  in either of maildir or mbox formats.

  The SQL drivers and authentication plug-ins are in their subpackages.


pkgId: 120e9a813a5b7fbc4b4956ff60d4b5b2e7e7b7b2
name: dwdiff
arch: src
version: 1.4
epoch: 0
release: 1
summary: Front end to diff for comparing files on a word per word basis
url: http://os.ghalkes.nl/dwdiff.html
rpm_license: OSL 2.0
rpm_vendor: End Point Corporation
rpm_group: Applications/Text
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: dwdiff-1.4-1.src.rpm
checksum_type: sha
description:
  dwdiff is a front-end for the diff program that operates at the word level
  instead of the line level. It is different from wdiff in that it allows the
  user to specify what should be considered whitespace, and in that it takes an
  optional list of characters that should be considered delimiters. Delimiters
  are single characters that are treated as if they are words, even when there
  is no whitespace separating them from preceding words or delimiters.


pkgId: f9f0171f86c7436303c4742126bc24d48f95cdaa
name: endpoint-im664-repo
arch: src
version: 1.0
epoch: 0
release: 1
summary: Yum configuration for End Point backported ImageMagick 6.6 RPM repository
url: https://packages.endpoint.com/
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point <hosting@endpoint.com>
location_href: endpoint-im664-repo-1.0-1.src.rpm
checksum_type: sha
description:
  This package contains the Yum configuration for the
  End Point backported ImageMagick 6.6 RPM repository.


pkgId: 81297d56317437d59a7ffb2ee3328e19ec58860c
name: endpoint-pg82-repo
arch: src
version: 1.0
epoch: 0
release: 1
summary: Yum configuration for End Point backported PostgreSQL 8.2 RPM repository
url: https://packages.endpoint.com/
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build32
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: endpoint-pg82-repo-1.0-1.src.rpm
checksum_type: sha
description:
  This package contains the Yum configuration and public GnuPG signing keys
  for the End Point backported PostgreSQL 8.2 RPM repositories.


pkgId: 6393bec4386b047286c32614d17fce5a341d63c0
name: endpoint-pg82-widt-repo
arch: src
version: 1.0
epoch: 0
release: 1
summary: Yum configuration for End Point backported PostgreSQL 8.2 RPM repository
url: https://packages.endpoint.com/
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: endpoint-pg82-widt-repo-1.0-1.src.rpm
checksum_type: sha
description:
  This package contains the Yum configuration and public GnuPG signing keys
  for the End Point backported PostgreSQL 8.2 (with-integer-datetimes) RPM repository.


pkgId: 6ef2e10a0ca2505f04e25afe02b46b0af9e8dacd
name: endpoint-pg83-repo
arch: src
version: 1.0
epoch: 0
release: 1
summary: Yum configuration for End Point backported PostgreSQL 8.3 RPM repository
url: https://packages.endpoint.com/
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: endpoint-pg83-repo-1.0-1.src.rpm
checksum_type: sha
description:
  This package contains the Yum configuration and public GnuPG signing keys
  for the End Point backported PostgreSQL 8.3 RPM repositories.


pkgId: a2e1b843d5aadfe91b5215a13e04a7af3b2dd2f0
name: endpoint-pg84-repo
arch: src
version: 1.0
epoch: 0
release: 1
summary: Yum configuration for End Point backported PostgreSQL 8.4 RPM repository
url: https://packages.endpoint.com/
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: endpoint-pg84-repo-1.0-1.src.rpm
checksum_type: sha
description:
  This package contains the Yum configuration and public GnuPG signing keys
  for the End Point backported PostgreSQL 8.3 RPM repository.


pkgId: d8dc9bf242d8f9d3f76f0ce35cf63f978753bfea
name: endpoint-repo
arch: src
version: 1.0
epoch: 0
release: 1
summary: Yum configuration for End Point main RPM repository
url: https://packages.endpoint.com/
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: endpoint-repo-1.0-1.src.rpm
checksum_type: sha
description:
  This package contains the Yum configuration and public GnuPG signing keys
  for the End Point main RPM repositories.


pkgId: c4e1af94b1afc7649edbba5d5da3f700c13ee951
name: endpoint-volatile-repo
arch: src
version: 1.0
epoch: 0
release: 1
summary: Yum configuration for End Point volatile/non-compatible RPM repository
url: https://packages.endpoint.com/
rpm_license: GPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Josh Williams <hosting@endpoint.com>
location_href: endpoint-volatile-repo-1.0-1.src.rpm
checksum_type: sha
description:
  This package contains the Yum configuration for the End Point
  volatile / RHEL 5 incompatible RPM repository.  Be careful with
  these, they may not be compatible when upgrading existing packages.


pkgId: 9a69d9d94e4f02dee74db4f0cdb32e3714e739db
name: eventlog
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: Syslog-ng v2 support library
url: http://www.balabit.com/products/syslog-ng/
rpm_license: BSD
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: eventlog-0.2.7-1.src.rpm
checksum_type: sha
description:
  The EventLog library aims to be a replacement of the simple syslog() API
  provided on UNIX systems. The major difference between EventLog and syslog
  is that EventLog tries to add structure to messages.

  EventLog provides an interface to build, format and output an event record.
  The exact format and output method can be customized by the administrator
  via a configuration file.

  This package is the runtime part of the library.


pkgId: 3e646e5914022e62a74d956a320a04978207d45f
name: facter
arch: src
version: 1.5.2
epoch: 0
release: 1.ep
summary: Ruby module for collecting simple facts about a host operating system
url: http://reductivelabs.com/projects/facter
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: facter-1.5.2-1.ep.src.rpm
checksum_type: sha
description:
  Ruby module for collecting simple facts about a host Operating
  system. Some of the facts are preconfigured, such as the hostname and the
  operating system. Additional facts can be added through simple Ruby scripts


pkgId: 0fb25ca761632a426fe33e924849ac93f0dee923
name: fakeroot
arch: src
version: 1.9.6
epoch: 0
release: 17
summary: Gives a fake root environment
url: http://fakeroot.alioth.debian.org/
rpm_license: GPL+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Tools
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: fakeroot-1.9.6-17.src.rpm
checksum_type: sha
description:
  fakeroot runs a command in an environment wherein it appears to have
  root privileges for file manipulation. fakeroot works by replacing the
  file manipulation library functions (chmod(2), stat(2) etc.) by ones
  that simulate the effect the real library functions would have had,
  had the user really been root.


pkgId: 7e5b173185859adb447e845036b7764f26ce44dc
name: fltk
arch: src
version: 1.1.9
epoch: 0
release: 1.ep
summary: C++ user interface toolkit
url: http://www.fltk.org/
rpm_license: LGPLv2+ with exceptions
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: fltk-1.1.9-1.ep.src.rpm
checksum_type: sha
description:
  FLTK (pronounced "fulltick") is a cross-platform C++ GUI toolkit.
  It provides modern GUI functionality without the bloat, and supports
  3D graphics via OpenGL and its built-in GLUT emulation.


pkgId: 29da39e8a4addd342bbcab57d54e270d4b91b32e
name: fping
arch: src
version: 2.4b2
epoch: 0
release: 8
summary: Scriptable, parallelized ping-like utility
url: http://www.fping.com/
rpm_license: BSD with advertising
rpm_vendor: End Point Corporation
rpm_group: Applications/Internet
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: fping-2.4b2-8.src.rpm
checksum_type: sha
description:
  fping is a ping-like program which can determine the accessibility of
  multiple hosts using ICMP echo requests. fping is designed for parallelized
  monitoring of large numbers of systems, and is developed with ease of
  use in scripting in mind.


pkgId: 072c4c36108c9d0d4e6f8131796cd3bb9d636a17
name: freetds
arch: src
version: 0.64
epoch: 0
release: 1
rpm_license: LGPL
rpm_vendor: www.freetds.org
rpm_group: System Environment/Libraries
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: End Point Corporation
location_href: freetds-0.64-1.src.rpm
checksum_type: sha
summary:
  FreeTDS is a free re-implementation of the TDS (Tabular DataStream) protocol that is used by Sybase and Microsoft for their database products.

description:
  FreeTDS is a project to document and implement the TDS (Tabular DataStream)
  protocol. TDS is used by Sybase and Microsoft for client to database server
  communications. FreeTDS includes call level interfaces for DB-Lib, CT-Lib,
  and ODBC.


pkgId: a82480c530fdd4afd95e4497f192c590e1b35e0d
name: git
arch: src
version: 1.5.6.2
epoch: 0
release: 1
summary: Core git tools
url: http://kernel.org/pub/software/scm/git/
rpm_license: GPL
rpm_group: Development/Tools
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: git-1.5.6.2-1.src.rpm
checksum_type: sha
description:
  Git is a fast, scalable, distributed revision control system with an
  unusually rich command set that provides both high-level operations
  and full access to internals.

  The git rpm installs the core tools with minimal dependencies.  To
  install all git packages, including tools for integrating with other
  SCMs, install the git-all meta-package.


pkgId: 29ad124674fe7d9aab255a0df5c510fde2e7d21d
name: git
arch: src
version: 2.5.0
epoch: 0
release: 1.ep
summary: Fast Version Control System
url: http://git-scm.com/
rpm_license: GPLv2
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Tools
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: git-2.5.0-1.ep.src.rpm
checksum_type: sha
description:
  Git is a fast, scalable, distributed revision control system with an
  unusually rich command set that provides both high-level operations
  and full access to internals.

  The git rpm installs common set of tools which are usually using with
  small amount of dependencies. To install all git packages, including
  tools for integrating with other SCMs, install the git-all meta-package.


pkgId: 34075b3dad4f97477eee181a66a6d20f11573041
name: git-user
arch: src
version: 20111024
epoch: 0
release: 1
summary: Easily change author and committer for git commands
url: http://www.endpoint.com/
rpm_license: Public domain
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/File
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: git-user-20111024-1.src.rpm
checksum_type: sha
description:
  git-user is a convenience wrapper for git commands that sets the author
  and committer from a predetermined list of usernames.


pkgId: 7f9192fda96ab9c62d26c3b307b98047667acad2
name: goat-webapp
arch: src
version: 0.3
epoch: 0
release: 2
summary: Goat Webapp - install Goat Webapp related RPMS
url: http://endpoint.com
rpm_license: Artistic
rpm_vendor: End Point Corporation
rpm_group: Applications/Web
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: EP Hosting <hosting@endpoint.com>
location_href: goat-webapp-0.3-2.src.rpm
checksum_type: sha
description:
  Goat Webapp - install Goat Webapp related RPMS

  Authen::NTLM
  Bundle::InterchangeKitchenSink
  Bundle::LWP
  Cache::Memcached
  Cache::Memcached::Fast
  CGI::Cache
  Compress::Zlib
  Data::Dump
  Date::Format
  Date::Manip
  DateTime::Format::Strptime
  DBD::Pg
  Digest::HMAC_SHA1
  Error
  Exception::Class
  File::Tail
  GD::Graph
  HTML::Lint
  HTML::Parser
  HTML::Scrubber
  HTML::TokeParser
  IO::Socket::SSL
  IO::String
  JSON -- old version 1.15
  LWP::Simple
  LWP::UserAgent
  Mail::POP3Client
  Mail::Sendmail
  MIME::Parser
  Module::Build
  Module::Reload
  Module::Signature
  MogileFS::Client
  Moose
  Net::Server::Mail
  Net::UPS
  PDF::API2
  PDF::Table
  Rose::DB::Object
  Set::Crontab
  SQL::Statement 0.1021
  Text::CSV_XS
  Text::ScriptTemplate
  URI
  WebService::Validator::HTML::W3C
  XML::LibXML
  XML::LibXSLT -- old version 1.62
  XML::Parser
  XML::RSS
  XML::Writer
  YAML 0.58


pkgId: 1aac074756e7ac22d33b0602e1e643bb7cac0364
name: goat-webapp
arch: src
version: 0.4
epoch: 0
release: 1
summary: Goat webapp - Goat web application dependencies
url: http://www.endpoint.com/
rpm_license: Artistic
rpm_vendor: End Point Corporation
rpm_group: Applications/Web
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting <hosting@endpoint.com>
location_href: goat-webapp-0.4-1.src.rpm
checksum_type: sha
description:
  Goat webapp: Goat web application dependencies.

  This package is just a way to collect all the dependencies for the goat webapp
  software. It installs no files of its own.


pkgId: 4ff8ff3e38f15dd624e29d8657fe4fab1ce4e1c2
name: graphviz
arch: src
version: 2.20.3
epoch: 0
release: 1.ep
summary: Graph Visualization Tools
url: http://www.graphviz.org/
rpm_license: CPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Multimedia
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: graphviz-2.20.3-1.ep.src.rpm
checksum_type: sha
description:
  A collection of tools for the manipulation and layout
  of graphs (as in nodes and edges, not as in barcharts).


pkgId: f77333c408f87afe8f9926410214d79981af6dc3
name: haproxy
arch: src
version: 1.3.22
epoch: 0
release: 2.ep
summary: HA-Proxy is a TCP/HTTP reverse proxy for high availability environments
url: http://haproxy.1wt.eu/
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Daemons
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: haproxy-1.3.22-2.ep.src.rpm
checksum_type: sha
description:
  HA-Proxy is a TCP/HTTP reverse proxy which is particularly suited for high
  availability environments. Indeed, it can:
  - route HTTP requests depending on statically assigned cookies
  - spread the load among several servers while assuring server persistence
    through the use of HTTP cookies
  - switch to backup servers in the event a main one fails
  - accept connections to special ports dedicated to service monitoring
  - stop accepting connections without breaking existing ones
  - add/modify/delete HTTP headers both ways
  - block requests matching a particular pattern


pkgId: 312ee30eb03ad3cfabadf47427b9e642debdf554
name: heartbeat
arch: src
version: 3.0.2
epoch: 0
release: 2.ep
summary: Messaging and membership subsystem for High-Availability Linux
url: http://linux-ha.org/
rpm_license: GPLv2 and LGPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Daemons
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: heartbeat-3.0.2-2.ep.src.rpm
checksum_type: sha
description:
  heartbeat is a basic high-availability subsystem for Linux-HA.
  It will run scripts at initialization, and when machines go up or down.
  This version will also perform IP address takeover using gratuitous ARPs.

  Heartbeat contains a cluster membership layer, fencing, and local and
  clusterwide resource management functionality.

  When used with Pacemaker, it supports "n-node" clusters with significant
  capabilities for managing resources and dependencies.

  In addition it continues to support the older release 1 style of
  2-node clustering.

  It implements the following kinds of heartbeats:
          - Serial ports
          - UDP/IP multicast (ethernet, etc)
          - UDP/IP broadcast (ethernet, etc)
          - UDP/IP heartbeats
          - "ping" heartbeats (for routers, switches, etc.)
             (to be used for breaking ties in 2-node systems)


pkgId: 4c0d1fd8d7ae7d815cc3a2ef1acdc2c98e2d7c56
name: help2man
arch: src
version: 1.36.4
epoch: 0
release: 2
summary: Create simple man pages from --help output
url: http://www.gnu.org/software/help2man
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Tools
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: help2man-1.36.4-2.src.rpm
checksum_type: sha
description:
  help2man is a script to create simple man pages from the --help and
  --version output of programs.

  Since most GNU documentation is now in info format, this provides a
  way to generate a placeholder man page pointing to that resource while
  still providing some useful information.


pkgId: a53ced8128c2712aa6a6de08f3d7a368e1a12570
name: htmldoc
arch: src
version: 1.8.27
epoch: 0
release: 7.ep
summary: Convert HTML source files into HTML, PostScript, or PDF
url: http://www.htmldoc.org/
rpm_license: GPLv2 with exceptions
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Publishing
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: htmldoc-1.8.27-7.ep.src.rpm
checksum_type: sha
description:
  HTMLDOC converts HTML source files into indexed HTML, PostScript, or
  Portable Document Format (PDF) files that can be viewed online or
  printed. With no options a HTML document is produced on stdout.

  The second form of HTMLDOC reads HTML source from stdin, which allows
  you to use HTMLDOC as a filter.

  The third form of HTMLDOC launches a graphical interface that allows
  you to change options and generate documents interactively.


pkgId: 81dcc2ee6c7d0e47a9ca8d9586fb116007764899
name: httperf
arch: src
version: 0.9.0
epoch: 0
release: 1.rf
summary: Web server benchmark
url: http://www.hpl.hp.com/research/linux/httperf/
rpm_license: GPL
rpm_vendor: Dag Apt Repository, http://dag.wieers.com/apt/
rpm_group: Applications/Internet
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Dag Wieers <dag@wieers.com>
location_href: httperf-0.9.0-1.rf.src.rpm
checksum_type: sha
description:
  httperf is a popular web server benchmark tool for measuring web server
  performance. It provides a flexible facility for generating various HTTP
  workloads and for measuring server performance. The focus of httperf is
  not on implementing one particular benchmark but on providing a robust,
  high-performance tool that  facilitates the construction of both micro-
  and macro-level benchmarks. The three distinguishing characteristics of
  httperf are its robustness, which includes the ability to generate and
  sustain server overload, support for the HTTP/1.1 protocol, and its
  extensibility to new workload generators and performance measurements.


pkgId: 44c59fa2bccb0d5a94afef014d4df61a95ae84cd
name: innotop
arch: src
version: 1.8.0
epoch: 0
release: 0
summary: A MySQL and InnoDB monitor program.
url: http://innotop.googlecode.com/
rpm_license: GPL/Artistic
rpm_vendor: Aaron Racine <aracine@gmail.com>
rpm_group: System/Monitoring
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Aaron Racine <aracine@gmail.com>
location_href: innotop-1.8.0-0.src.rpm
checksum_type: sha
description:
  MySQL and InnoDB transaction/status monitor.  Like 'top' for MySQL.  Displays
  queries, InnoDB transactions, lock waits, deadlocks, foreign key errors, open
  tables, replication status, buffer information, row operations, logs, I/O
  operations, load graph, and more.  You can monitor many servers at once with
  innotop.


pkgId: 93ab035adb1e8962a6c81f3ddefd7150f0ad6077
name: iptstate
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Display IP Tables state table information in a "top"-like interface
url: http://www.phildev.net/iptstate/
rpm_license: zlib License
rpm_vendor: End Point Corporation
rpm_group: Applications/System
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: End Point Corporation
location_href: iptstate-2.2.1-1.src.rpm
checksum_type: sha
description:
  IP Tables State (iptstate) was originally written to
  impliment the "state top" feature of IP Filter.
  "State top" displays the states held by your stateful
  firewall in a "top"-like manner.


pkgId: f509e5dbfd9da0dbca9ad97d134bc3b13fad6ac7
name: jasper
arch: src
version: 1.900.1
epoch: 0
release: 13.ep
summary: Implementation of the JPEG-2000 standard, Part 1
url: http://www.ece.uvic.ca/~mdadams/jasper/
rpm_license: JasPer
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: jasper-1.900.1-13.ep.src.rpm
checksum_type: sha
description:
  This package contains an implementation of the image compression
  standard JPEG-2000, Part 1. It consists of tools for conversion to and
  from the JP2 and JPC formats.


pkgId: 52138574416fc742e7f71579baa86b8904486c19
name: lftp
arch: src
version: 4.1.3
epoch: 0
release: 1.ep
summary: A sophisticated file transfer program
url: http://lftp.yar.ru/
rpm_license: GPLv3+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Internet
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: lftp-4.1.3-1.ep.src.rpm
checksum_type: sha
description:
  LFTP is a sophisticated ftp/http file transfer program. Like bash, it has job
  control and uses the readline library for input. It has bookmarks, built-in
  mirroring, and can transfer several files in parallel. It is designed with
  reliability in mind.


pkgId: 772f337335b6dbdc3140ec27dfd16b88b1bbf92e
name: libdnet
arch: src
version: 1.12
epoch: 0
release: 6.ep
summary: Simple portable interface to lowlevel networking routines
url: http://code.google.com/p/libdnet/
rpm_license: BSD
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: libdnet-1.12-6.ep.src.rpm
checksum_type: sha
description:
  libdnet provides a simplified, portable interface to several
  low-level networking routines, including network address
  manipulation, kernel arp(4) cache and route(4) table lookup and
  manipulation, network firewalling (IP filter, ipfw, ipchains,
  pf, ...), network interface lookup and manipulation, raw IP
  packet and Ethernet frame, and data transmission.


pkgId: c1a4b00b11e27c2057593fafa05ece77a3541d90
name: libedit
arch: src
version: 2.11
epoch: 0
release: 3.20080712cvs.ep
summary: The NetBSD Editline library
url: http://www.thrysoee.dk/editline/
rpm_license: BSD
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: libedit-2.11-3.20080712cvs.ep.src.rpm
checksum_type: sha
description:
  Libedit is an autotool- and libtoolized port of the NetBSD Editline library.
  It provides generic line editing, history, and tokenization functions, similar
  to those found in GNU Readline.


pkgId: 49f92f9e8cdde1970789bc4f6f4915989d20f5d0
name: libesmtp
arch: src
version: 1.0.4
epoch: 0
release: 5.ep
summary: SMTP client library
url: http://www.stafford.uklinux.net/libesmtp/
rpm_license: LGPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: libesmtp-1.0.4-5.ep.src.rpm
checksum_type: sha
description:
  LibESMTP is a library to manage posting (or submission of) electronic
  mail using SMTP to a preconfigured Mail Transport Agent (MTA) such as
  Exim. It may be used as part of a Mail User Agent (MUA) or another
  program that must be able to post electronic mail but where mail
  functionality is not the program's primary purpose.


pkgId: d1913e22c8c34ad6874d1716490e07bb06a8559f
name: libiptcdata
arch: src
version: 1.0.2
epoch: 0
release: 1.ep
summary: IPTC tag library
url: http://libiptcdata.sourceforge.net/
rpm_license: LGPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: libiptcdata-1.0.2-1.ep.src.rpm
checksum_type: sha
description:
  libiptcdata is a library for parsing, editing, and saving IPTC data
  stored inside images.  IPTC is a standard for encoding metadata such
  as captions, titles, locations, etc. in the headers of an image file.
  libiptcdata also includes a command-line utility for modifying the
  metadata.


pkgId: 45a5b362d4b55597c2b01c9fecf2e09a5d1ad5f8
name: libmcrypt
arch: src
version: 2.5.7
epoch: 0
release: 5
summary: Encryption algorithms library
url: http://mcrypt.sourceforge.net/
rpm_license: LGPL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: libmcrypt-2.5.7-5.src.rpm
checksum_type: sha
description:
  Libmcrypt is a thread-safe library providing a uniform interface
  to access several block and stream encryption algorithms.


pkgId: 2e0bc25a36bc2795297d1900c083b112dd2e5700
name: libnet
arch: src
version: 1.1.4
epoch: 0
release: 4.ep
summary: C library for portable packet creation and injection
url: http://www.sourceforge.net/projects/libnet-dev/
rpm_license: BSD
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: libnet-1.1.4-4.ep.src.rpm
checksum_type: sha
description:
  Libnet is an API to help with the construction and handling of network
  packets. It provides a portable framework for low-level network packet
  writing and handling (use libnet in conjunction with libpcap and you can
  write some really cool stuff). Libnet includes packet creation at the IP
  layer and at the link layer as well as a host of supplementary and
  complementary functionality.


pkgId: 5e40275566d2ba9cfc68c7e25973297d4cb86ee0
name: libnetfilter_conntrack
arch: src
version: 0.0.50
epoch: 0
release: 2
summary: Netfilter conntrack userspace library
url: http://netfilter.org/
rpm_license: GPL
rpm_vendor: End Point Corporation
rpm_group: System Environment/Libraries
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Dag Wieers <dag@wieers.com>
location_href: libnetfilter_conntrack-0.0.50-2.src.rpm
checksum_type: sha
description:
  libnetfilter_conntrack is a userspace library providing a programming
  interface (API) to the in-kernel connection tracking state table.


pkgId: 2a37cd77a079c52eba08ef8a4a242b556b2c9b45
name: libnfnetlink
arch: src
version: 0.0.25
epoch: 0
release: 2
summary: Netfilter netlink userspace library
url: http://netfilter.org/
rpm_license: GPL
rpm_vendor: End Point Corporation
rpm_group: System Environment/Libraries
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Dag Wieers <dag@wieers.com>
location_href: libnfnetlink-0.0.25-2.src.rpm
checksum_type: sha
description:
  libnfnetlink is a userspace library that provides some low-level
  nfnetlink handling functions. It is used as a foundation for other, netfilter
  subsystem specific libraries such as libnfnetlink_conntrack, libnfnetlink_log
  and libnfnetlink_queue.


pkgId: d7fa1282d60a55ea365dfa5a202fa52799168540
name: libpcap10
arch: src
version: 1.0.0
epoch: 14
release: 7.20091201git117cb5.ep
summary: A system-independent interface for user-level packet capture
url: http://www.tcpdump.org
rpm_license: BSD with advertising
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: libpcap10-1.0.0-7.20091201git117cb5.ep.src.rpm
checksum_type: sha
description:
  Libpcap provides a portable framework for low-level network
  monitoring.  Libpcap can provide network statistics collection,
  security monitoring and network debugging.  Since almost every system
  vendor provides a different interface for packet capture, the libpcap
  authors created this system-independent API to ease in porting and to
  alleviate the need for several system-dependent packet capture modules
  in each application.

  Install libpcap if you need to do low-level network traffic monitoring
  on your network.


pkgId: 2c9a142ae137476ed16b3699cce4aa45df1d04e6
name: librelp
arch: src
version: 0.1.1
epoch: 0
release: 2
summary: The Reliable Event Logging Protocol library
url: http://www.rsyslog.com/
rpm_license: GPLv3+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: librelp-0.1.1-2.src.rpm
checksum_type: sha
description:
  Librelp is an easy to use library for the RELP protocol. RELP (stands
  for Reliable Event Logging Protocol) is a general-purpose, extensible
  logging protocol.


pkgId: 3821ecf24ebedb97f43243d54e51df30017e7042
name: libstatgrab
arch: src
version: 0.13
epoch: 0
release: 4.ep
summary: Make system statistics
url: http://www.i-scream.org/libstatgrab/
rpm_license: LGPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Libraries
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: libstatgrab-0.13-4.ep.src.rpm
checksum_type: sha
description:
  Libstatgrab is a library that provides cross platform access to statistics
  about the system on which it's run. It's written in C and presents a selection
  of useful interfaces which can be used to access key system statistics. The
  current list of statistics includes CPU usage, memory utilisation, disk usage,
  process counts, network traffic, disk I/O, and more.

  The current list of platforms is Solaris 2.x, Linux, and FreeBSD 4.x/5.x.
  The aim is to extend this to include as many operating systems as possible.

  The package also includes a couple of useful tools. The first, saidar,
  provides a curses-based interface to viewing the current state of the
  system. The second, statgrab, gives a sysctl-style interface to the
  statistics gathered by libstatgrab. This extends the use of libstatgrab
  to people writing scripts or anything else that can't easily make C
  function calls. Included with statgrab is a script to generate an MRTG
  configuration file to use statgrab.


pkgId: ae4dd5660e24c82a9e0624a97f02c528d4e777c0
name: lighttpd
arch: src
version: 1.4.19
epoch: 0
release: 4
summary: Lightning fast webserver with light system requirements
url: http://www.lighttpd.net/
rpm_license: BSD
rpm_vendor: End Point Corporation
rpm_group: System Environment/Daemons
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: lighttpd-1.4.19-4.src.rpm
checksum_type: sha
description:
  Secure, fast, compliant and very flexible web-server which has been optimized
  for high-performance environments. It has a very low memory footprint compared
  to other webservers and takes care of cpu-load. Its advanced feature-set
  (FastCGI, CGI, Auth, Output-Compression, URL-Rewriting and many more) make
  it the perfect webserver-software for every server that is suffering load
  problems.

  Available rpmbuild rebuild options :
  --with : gamin webdavprops webdavlocks memcache
  --without : ldap gdbm lua (cml)


pkgId: 7a0a6ff52163014a2189f680efb0fe66cb185084
name: local-ImageMagick
arch: src
version: 6.2.8.0
epoch: 0
release: 15.ep
summary: An X application for displaying and manipulating images.
url: http://www.imagemagick.org/
rpm_license: freeware
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Multimedia
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: local-ImageMagick-6.2.8.0-15.ep.src.rpm
checksum_type: sha
description:
  ImageMagick(TM) is an image display and manipulation tool for the X
  Window System. ImageMagick can read and write JPEG, TIFF, PNM, GIF,
  and Photo CD image formats. It can resize, rotate, sharpen, color
  reduce, or add special effects to an image, and when finished you can
  either save the completed work in the original format or a different
  one. ImageMagick also includes command line programs for creating
  animated or transparent .gifs, creating composite images, creating
  thumbnail images, and more.

  ImageMagick is one of your choices if you need a program to manipulate
  and dis play images. If you want to develop your own applications
  which use ImageMagick code or APIs, you need to install
  ImageMagick-devel as well.


pkgId: ce20a556cdb7daca7535468626f653dc2d89e7ba
name: local-mod_perl
arch: src
version: 2.0.2
epoch: 0
release: 6.3
summary: An embedded Perl interpreter for the Apache Web server
url: http://perl.apache.org/
rpm_license: GPL
rpm_vendor: End Point Corporation
rpm_group: System Environment/Daemons
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: local-mod_perl-2.0.2-6.3.src.rpm
checksum_type: sha
description:
  Mod_perl incorporates a Perl interpreter into the Apache web server,
  so that the Apache web server can directly execute Perl code.
  Mod_perl links the Perl runtime library into the Apache web server and
  provides an object-oriented Perl interface for Apache's C language
  API.  The end result is a quicker CGI script turnaround process, since
  no external Perl interpreter has to be started.

  Install mod_perl if you're installing the Apache web server and you'd
  like for it to directly incorporate a Perl interpreter.


pkgId: 81f22aca2073e5d6a71ffb543e6803caad45ca25
name: local-perl
arch: src
version: 5.10.0
epoch: 4
release: 38
summary: The Perl programming language, local build
url: http://www.perl.org/
rpm_license: (GPL+ or Artistic) and (GPLv2+ or Artistic)
rpm_group: Development/Languages
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: local-perl-5.10.0-38.src.rpm
checksum_type: sha
description:
  Perl is a high-level programming language with roots in C, sed, awk
  and shell scripting.  Perl is good at handling processes and files,
  and is especially good at handling text.  Perl's hallmarks are
  practicality and efficiency.  While it is used to do a lot of
  different things, Perl's most common applications are system
  administration utilities and web programming.  A large proportion of
  the CGI scripts on the web are written in Perl.  You need the perl
  package installed on your system so that your system can handle Perl
  scripts.

  Install this package if you want to program in Perl or enable your
  system to handle Perl scripts.


pkgId: d53cb6cbf6726f53631a16e3721199b4889394e8
name: local-perl-Algorithm-Annotate
arch: src
version: 0.10
epoch: 0
release: 1
summary: Algorithm-Annotate - Represent a series of changes in annotation list
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Chia-liang Kao (clkao@clkao.org)
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Algorithm-Annotate-0.10-1.src.rpm
checksum_type: sha
description:
  Algorithm::Annotate generates a list that is useful for generating
  output simliar to C<cvs annotate>.


pkgId: 64538f1b98250e0badf45dd9b6c7a3852295d4f0
name: local-perl-Algorithm-Diff
arch: src
version: 1.15
epoch: 0
release: 1
summary: Algorithm-Diff - Compute `intelligent' differences between two files / lists
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Ned Konz <perl@bike-nomad.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Algorithm-Diff-1.15-1.src.rpm
checksum_type: sha
description:
  use Algorithm::Diff qw(diff sdiff LCS traverse_sequences
                           traverse_balanced);

    @lcs    = LCS( \@seq1, \@seq2 );

    @lcs    = LCS( \@seq1, \@seq2, $key_generation_function );

    $lcsref = LCS( \@seq1, \@seq2 );

    $lcsref = LCS( \@seq1, \@seq2, $key_generation_function );

    @diffs = diff( \@seq1, \@seq2 );

    @diffs = diff( \@seq1, \@seq2, $key_generation_function );

    @sdiffs = sdiff( \@seq1, \@seq2 );

    @sdiffs = sdiff( \@seq1, \@seq2, $key_generation_function );

    traverse_sequences( \@seq1, \@seq2,
                       { MATCH => $callback,
                         DISCARD_A => $callback,
                         DISCARD_B => $callback,
                       } );

    traverse_sequences( \@seq1, \@seq2,
                       { MATCH => $callback,
                         DISCARD_A => $callback,
                         DISCARD_B => $callback,
                       },
                       $key_generation_function );

    traverse_balanced( \@seq1, \@seq2,
                       { MATCH => $callback,
                         DISCARD_A => $callback,
                         DISCARD_B => $callback,
                         CHANGE    => $callback,
                       } );


pkgId: d04f0a717ee43aebd97bff99cc8c85438a5c0226
name: local-perl-Any-Moose
arch: src
version: 0.13
epoch: 0
release: 1
summary: Any-Moose - use Moose or Mouse modules
description: None.
url: http://www.cpan.org
rpm_license: Artistic
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Any-Moose-0.13-1.src.rpm
checksum_type: sha
rpm_vendor:
  Shawn M Moore <sartak@bestpractical.com>, Florian Ragwitz <rafl@debian.org>, Stevan Little <stevan@iinteractive.com>, Tokuhiro Matsuno <tokuhirom@gmail.com>, Goro Fuji <gfuji@cpan.org>


pkgId: 46d57137a6e106a9e38132224c5f07983a07e4de
name: local-perl-Any-Moose
arch: src
version: 0.18
epoch: 0
release: 1
summary: Any-Moose - use Moose or Mouse modules
description: None.
url: http://www.cpan.org
rpm_license: Artistic
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Any-Moose-0.18-1.src.rpm
checksum_type: sha
rpm_vendor:
  Shawn M Moore <sartak@gmail.com>, Florian Ragwitz <rafl@debian.org>, Stevan Little <stevan@iinteractive.com>, Tokuhiro Matsuno <tokuhirom@gmail.com>, Goro Fuji <gfuji@cpan.org>, Ricardo Signes <rjbs@cpan.org>


pkgId: ef4f04f1ff339d4216dd68df5775d33cf29c0b0a
name: local-perl-AnyEvent
arch: src
version: 5.251
epoch: 0
release: 1
summary: AnyEvent - the DBI of event loop programming
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Marc Lehmann <schmorp@schmorp.de>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-AnyEvent-5.251-1.src.rpm
checksum_type: sha
description:
  L<AnyEvent> provides an identical interface to multiple event loops. This
  allows module authors to utilise an event loop without forcing module
  users to use the same event loop (as only a single event loop can coexist
  peacefully at any one time).

  The interface itself is vaguely similar, but not identical to the L<Event>
  module.

  During the first call of any watcher-creation method, the module tries
  to detect the currently loaded event loop by probing whether one of the
  following modules is already loaded: L<EV>,
  L<Event>, L<Glib>, L<AnyEvent::Impl::Perl>, L<Tk>, L<Event::Lib>, L<Qt>,
  L<POE>. The first one found is used. If none are found, the module tries
  to load these modules (excluding Tk, Event::Lib, Qt and POE as the pure perl
  adaptor should always succeed) in the order given. The first one that can
  be successfully loaded will be used. If, after this, still none could be
  found, AnyEvent will fall back to a pure-perl event loop, which is not
  very efficient, but should work everywhere.

  Because AnyEvent first checks for modules that are already loaded, loading
  an event model explicitly before first using AnyEvent will likely make
  that model the default. For example:

     use Tk;
     use AnyEvent;

     

  The I<likely> means that, if any module loads another event model and
  starts using it, all bets are off. Maybe you should tell their authors to
  use AnyEvent so their modules work together with others seamlessly...

  The pure-perl implementation of AnyEvent is called
  C<AnyEvent::Impl::Perl>. Like other event modules you can load it
  explicitly and enjoy the high availability of that event loop :)


pkgId: 38f79f2e37191b37b670c0135917b46e9114fd03
name: local-perl-AnyEvent-HTTP
arch: src
version: 1.44
epoch: 0
release: 1
summary: AnyEvent-HTTP - simple but non-blocking HTTP/HTTPS client
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Marc Lehmann <schmorp@schmorp.de>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-AnyEvent-HTTP-1.44-1.src.rpm
checksum_type: sha
description:
  This module is an L<AnyEvent> user, you need to make sure that you use and
  run a supported event loop.

  This module implements a simple, stateless and non-blocking HTTP
  client. It supports GET, POST and other request methods, cookies and more,
  all on a very low level. It can follow redirects supports proxies and
  automatically limits the number of connections to the values specified in
  the RFC.

  It should generally be a "good client" that is enough for most HTTP
  tasks. Simple tasks should be simple, but complex tasks should still be
  possible as the user retains control over request and response headers.

  The caller is responsible for authentication management, cookies (if
  the simplistic implementation in this module doesn't suffice), referer
  and other high-level protocol details for which this module offers only
  limited support.


pkgId: afc9614addfb6fc025e59efad56726362b73f305
name: local-perl-Apache-Cache
arch: src
version: 0.05
epoch: 0
release: 1
summary: Apache-Cache - Cache data accessible between Apache childrens
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Olivier Poitrey <rs@rhapsodyk.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Apache-Cache-0.05-1.src.rpm
checksum_type: sha
description:
  This module allows you to cache data easily through shared memory. Whithin the framework
  of an apache/mod_perl use, this cache is accessible from any child process. The data
  validity is managed in the Cache::Cache model, but as well based on time than on size
  or number of keys.

  Additionnally, you can implement a cache with Apache::Cache in your module without the risk
  of namespace clash because Apache::Cache is enclosed in the constructor's package's caller
  (see L<Apache::SharedMem> for more details).


pkgId: 81cbcbc082b297480c90d2e5a3a350871374d727
name: local-perl-Apache-ConfigParser
arch: src
version: 1.01
epoch: 0
release: 1
summary: Apache-ConfigParser - Load Apache configuration files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Blair Zajac <blair@orcaware.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Apache-ConfigParser-1.01-1.src.rpm
checksum_type: sha
description:
  The C<Apache::ConfigParser> module is used to load an Apache
  configuration file to allow programs to determine Apache's
  configuration directives and contexts.  The resulting object contains
  a tree based structure using the C<Apache::ConfigParser::Directive>
  class, which is a subclass of C<Tree::DAG_node>, so all of the methods
  that enable tree based searches and modifications from
  C<Tree::DAG_Node> are also available.  The tree structure is used to
  represent the ability to nest sections, such as <VirtualHost>,
  <Directory>, etc.

  Apache does a great job of checking Apache configuration files for
  errors and this modules leaves most of that to Apache.  This module
  does minimal configuration file checking.  The module currently checks
  for:

  =over 4

  =item Start and end context names match

  The module checks if the start and end context names match.  If the
  end context name does not match the start context name, then it is
  ignored.  The module does not even check if the configuration contexts
  have valid names.

  =back


pkgId: dfa4c6014df5785c1aaff3cebbc378c13ccfd527
name: local-perl-Apache-DBI
arch: src
version: 1.07
epoch: 0
release: 1
summary: Apache-DBI - Initiate a persistent database connection
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Apache-DBI-1.07-1.src.rpm
checksum_type: sha
description:
  This module initiates a persistent database connection.

  The database access uses Perl's DBI. For supported DBI drivers see:

   http://dbi.perl.org/

  When loading the DBI module (do not confuse this with the Apache::DBI module)
  it checks if the environment variable 'MOD_PERL' has been set
  and if the module Apache::DBI has been loaded. In this case every connect
  request will be forwarded to the Apache::DBI module. This checks if a database
  handle from a previous connect request is already stored and if this handle is
  still valid using the ping method. If these two conditions are fulfilled it
  just returns the database handle. The parameters defining the connection have
  to be exactly the same, including the connect attributes! If there is no
  appropriate database handle or if the ping method fails, a new connection is
  established and the handle is stored for later re-use. There is no need to
  remove the disconnect statements from your code. They won't do anything
  because the Apache::DBI module overloads the disconnect method.

  The Apache::DBI module still has a limitation: it keeps database connections
  persistent on a per process basis. The problem is, if a user accesses a database
  several times, the http requests will be handled very likely by different
  processes. Every process needs to do its own connect. It would be nice if all
  servers could share the database handles, but currently this is not possible
  because of the distinct memory-space of each process. Also it is not possible
  to create a database handle upon startup of the httpd and then inherit this
  handle to every subsequent server. This will cause clashes when the handle is
  used by two processes at the same time.  Apache::DBI has built-in protection
  against this.  It will not make a connection persistent if it sees that it is
  being opened during the server startup.  This allows you to safely open a connection
  for grabbing data needed at startup and disconnect it normally before the end of
  startup.

  With this limitation in mind, there are scenarios, where the usage of
  Apache::DBI is depreciated. Think about a heavy loaded Web-site where every
  user connects to the database with a unique userid. Every server would create
  many database handles each of which spawning a new backend process. In a short
  time this would kill the web server.

  Another problem are timeouts: some databases disconnect the client after a
  certain period of inactivity. The module tries to validate the database handle
  using the C<ping()> method of the DBI-module. This method returns true by default.
  Most DBI drivers have a working C<ping()> method, but if the driver you're using
  doesn't have one and the database handle is no longer valid, you will get an error
  when accessing the database. As a work-around you can try to add your own C<ping()>
  method using any database command which is cheap and safe, or you can deactivate the
  usage of the ping method (see CONFIGURATION below).

  Here is a generalized ping method, which can be added to the driver module:

     package DBD::xxx::db; # ====== DATABASE ======
     use strict;

     sub ping {
       my ($dbh) = @_;
       my $ret = 0;
       eval {
         local $SIG{__DIE__}  = sub { return (0); };
         local $SIG{__WARN__} = sub { return (0); };
         
         $ret = $dbh->do('select 1');
       };
       return ($@) ? 0 : $ret;
     }

  Transactions: a standard DBI script will automatically perform a rollback
  whenever the script exits. In the case of persistent database connections,
  the database handle will not be destroyed and hence no automatic rollback
  will occur. At a first glance it even seems possible to handle a transaction
  over multiple requests. But this should be avoided, because different
  requests are handled by different processes and a process does not know the state
  of a specific transaction which has been started by another process. In general,
  it is good practice to perform an explicit commit or rollback at the end of
  every request. In order to avoid inconsistencies in the database in case
  AutoCommit is off and the script finishes without an explicit rollback, the
  Apache::DBI module uses a PerlCleanupHandler to issue a rollback at the
  end of every request. Note, that this CleanupHandler will only be used, if
  the initial data_source sets AutoCommit = 0 or AutoCommit is turned off, after
  the connect has been done (ie begin_work). However, because a connection may
  have set other parameters, the handle is reset to its initial connection state
  before it is returned for a second time.

  This module plugs in a menu item for Apache::Status or Apache2::Status.
  The menu lists the current database connections. It should be considered
  incomplete because of the limitations explained above. It shows the current
  database connections for one specific process, the one which happens to serve
  the current request.  Other processes might have other database connections.
  The Apache::Status/Apache2::Status module has to be loaded before the
  Apache::DBI module !


pkgId: a98808764ce565dc46a4e3ec7be594f4ebe12e40
name: local-perl-Apache-Htpasswd
arch: src
version: 1.8
epoch: 0
release: 1
summary: Apache-Htpasswd - Manage Unix crypt-style password file.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: and comments to <kmeltz@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Apache-Htpasswd-1.8-1.src.rpm
checksum_type: sha
description:
  This module comes with a set of methods to use with htaccess password
  files. These files (and htaccess) are used to do Basic Authentication
  on a web server.

  The passwords file is a flat-file with login name and their associated
  crypted password. You can use this for non-Apache files if you wish, but
  it was written specifically for .htaccess style files.


pkgId: 91b8e5edf08c911bee57c955f591b608fff3e330
name: local-perl-Apache-Session
arch: src
version: 1.81
epoch: 0
release: 1
summary: Apache-Session - A persistence framework for session data
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Jeffrey Baker <jwbaker@acm.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Apache-Session-1.81-1.src.rpm
checksum_type: sha
description:
  Apache::Session is a persistence framework which is particularly useful
  for tracking session data between httpd requests.  Apache::Session is
  designed to work with Apache and mod_perl, but it should work under
  CGI and other web servers, and it also works outside of a web server
  altogether.

  Apache::Session consists of five components: the interface, the object store,
  the lock manager, the ID generator, and the serializer.  The interface is
  defined in Session.pm, which is meant to be easily subclassed.  The object
  store can be the filesystem, a Berkeley DB, a MySQL DB, an Oracle DB, a
  Postgres DB, Sybase, or Informix. Locking is done by lock files, semaphores, or
  the locking capabilities of the various databases.  Serialization is done via
  Storable, and optionally ASCII-fied via MIME or pack().  ID numbers are
  generated via MD5.  The reader is encouraged to extend these capabilities to
  meet his own requirements.

  A derived class of Apache::Session is used to tie together the three
  components.  The derived class inherits the interface from Apache::Session, and
  specifies which store and locker classes to use.  Apache::Session::MySQL, for
  instance, uses the MySQL storage class and also the MySQL locking class. You
  can easily plug in your own object store or locker class.


pkgId: 4366da0adbbe6639c1306e4c6f621275767e1d44
name: local-perl-Apache-SharedMem
arch: src
version: 0.09
epoch: 0
release: 1
summary: Apache-SharedMem - Share data between Apache children processes through the shared memory
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Olivier Poitrey <rs@rhapsodyk.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Apache-SharedMem-0.09-1.src.rpm
checksum_type: sha
description:
  This module make it easier to share data between Apache children processes through shared memory.
  This module internal functionment is much inspired from IPC::SharedCache, but without any cache management.
  The share memory segment key is automatically deduced by the caller package, which means that 2 modules
  can use same keys without being concerned about namespace clash. An additionnal namespace is used per application,
  which means that the same module, with the same namespace used in two applications doesn't clash too. Application
  distinction is made on two things : the process' UID and DOCUMENT_ROOT (for http applications) or current
  working directory.

  This module handles all shared memory interaction via the IPC::SharedLite and all data
  serialization with Storable. See L<IPC::ShareLite> and L<Storable> for details.


pkgId: 202a31353ee1354ec0b82474a638fed36fdd9f20
name: local-perl-AppConfig
arch: src
version: 1.66
epoch: 0
release: 1
description: None.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andy Wardley <abw@wardley.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-AppConfig-1.66-1.src.rpm
checksum_type: sha
summary:
  AppConfig - AppConfig is a bundle of Perl5 modules for reading configuration files and parsing command line arguments.


pkgId: 5f5548d82b004fa7ba7765da596a9caa7a3497f6
name: local-perl-Archive-Zip
arch: src
version: 1.23
epoch: 0
release: 1
summary: Archive-Zip - Provide an interface to ZIP archive files.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ned Konz <perl@bike-nomad.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Archive-Zip-1.23-1.src.rpm
checksum_type: sha
description:
  The Archive::Zip module allows a Perl program to create, manipulate, read,
  and write Zip archive files.

  Zip archives can be created, or you can read from existing zip files.

  Once created, they can be written to files, streams, or strings. Members
  can be added, removed, extracted, replaced, rearranged, and enumerated.
  They can also be renamed or have their dates, comments, or other attributes
  queried or modified. Their data can be compressed or uncompressed as needed.

  Members can be created from members in existing Zip files, or from existing
  directories, files, or strings.

  This module uses the L<Compress::Zlib> library to read and write the
  compressed streams inside the files.


pkgId: a44a56f30e43524eca73789bd2ab47a19166072f
name: local-perl-Archive-Zip
arch: src
version: 1.27_01
epoch: 0
release: 1
summary: Archive-Zip - Provide an interface to ZIP archive files.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ned Konz <perl@bike-nomad.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Archive-Zip-1.27_01-1.src.rpm
checksum_type: sha
description:
  The Archive::Zip module allows a Perl program to create, manipulate, read,
  and write Zip archive files.

  Zip archives can be created, or you can read from existing zip files.

  Once created, they can be written to files, streams, or strings. Members
  can be added, removed, extracted, replaced, rearranged, and enumerated.
  They can also be renamed or have their dates, comments, or other attributes
  queried or modified. Their data can be compressed or uncompressed as needed.

  Members can be created from members in existing Zip files, or from existing
  directories, files, or strings.

  This module uses the L<Compress::Zlib> library to read and write the
  compressed streams inside the files.

  One can use L<Archive::Zip::MemberRead> to read the zip file archive members
  as if they were files.


pkgId: 88563c4a76d05c90545995ed15505612fbe90c2f
name: local-perl-Authen-Captcha
arch: src
version: 1.023
epoch: 0
release: 1
summary: Authen-Captcha - Perl extension for creating captcha's to verify the human element in transactions.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Seth T. Jackson <sjackson@purifieddata.net>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Authen-Captcha-1.023-1.src.rpm
checksum_type: sha
description:
  use Authen::Captcha;

    
    my $captcha = Authen::Captcha->new();

    
    $captcha->data_folder('/some/folder');

    
    $captcha->output_folder('/some/http/folder');

    
    

    my $captcha = Authen::Captcha->new(
      data_folder => '/some/folder',
      output_folder => '/some/http/folder',
      );

    
    my $md5sum = $captcha->generate_code($number_of_characters);

    
    
    
    my $results = $captcha->check_code($code,$md5sum);


pkgId: 05b115a1db7205d2c0e2afd787aacee6d46d40fd
name: local-perl-Authen-Htpasswd
arch: src
version: 0.161
epoch: 0
release: 1
summary: Authen-Htpasswd - Interface to read and modify Apache .htpasswd files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David Kamholz <dkamholz@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Authen-Htpasswd-0.161-1.src.rpm
checksum_type: sha
description:
  This module provides a convenient, object-oriented interface to Apache-style
  F<.htpasswd> files.

  It supports passwords encrypted via MD5, SHA1, and crypt, as well as plain
  (cleartext) passwords.

  Additional fields after username and password, if present, are accessible via
  the C<extra_info> array.


pkgId: 78cadf5a9543fc1e1adba8fbfde40783acb6454e
name: local-perl-Authen-NTLM
arch: src
version: 0.31
epoch: 0
release: 1
summary: Authen-NTLM - Perl extension for NTLM related computations
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Yee Man Chan <ymc@yahoo.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Authen-NTLM-0.31-1.src.rpm
checksum_type: sha
description:
  The NTLM (Windows NT LAN Manager) authentication scheme is the authentication
  algorithm used by Microsoft.

  NTLM authentication scheme is used in DCOM and HTTP environment.
  It is used to authenticate DCE RPC packets in DCOM. It is also used to
  authenticate HTTP packets to MS Web Proxy or MS Web Server.

  Currently, it is the authentication scheme Internet Explorer chooses to
  authenticate itself to proxies/web servers that supports NTLM.

  As of this version, NTLM module only provides the client side functions
  to calculate NT response and LM response. The next revision will provide
  the server side functions that computes the nonce and verify the NTLM responses.

  This module was written without the knowledge of Mark Bush's (MARKBUSH)
  NTLM implementation. It was used by Yee Man Chan to implement a Perl
  DCOM client.


pkgId: 217757ac362b0d8575b02e2e3f4958cd4a115124
name: local-perl-Authen-NTLM
arch: src
version: 1.05
epoch: 0
release: 1
summary: Authen-NTLM - An NTLM authentication module
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David (Buzz) Bussenschutt <davidbuzz@gmail.com>, Mark Bush <Mark.Bush@bushnet.demon.co.uk>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Authen-NTLM-1.05-1.src.rpm
checksum_type: sha
description:
  This module provides methods to use NTLM authentication.  It can
      be used as an authenticate method with the Mail::IMAPClient module
      to perform the challenge/response mechanism for NTLM connections
      or it can be used on its own for NTLM authentication with other
      protocols (eg. HTTP).

      The implementation is a direct port of the code from F<fetchmail>
      which, itself, has based its NTLM implementation on F<samba>.  As
      such, this code is not especially efficient, however it will still
      take a fraction of a second to negotiate a login on a PII which is
      likely to be good enough for most situations.


pkgId: 9eaa5c217dd10ba6d604ed23fa2237bcea602e2c
name: local-perl-B-Keywords
arch: src
version: 1.08
epoch: 0
release: 1
summary: B-Keywords - Lists of reserved barewords and symbol names
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Joshua ben Jore <jjore@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-B-Keywords-1.08-1.src.rpm
checksum_type: sha
description:
  C<B::Keywords> supplies seven arrays of keywords: C<@Scalars>,
  C<@Arrays>, C<@Hashes>, C<@Filehandles>, C<@Symbols>, C<@Functions>,
  and C<@Barewords>. The C<@Symbols> array includes the contents of each
  of C<@Scalars>, C<@Arrays>, C<@Hashes>, and C<@Filehandles>.
  Similarly, C<@Barewords> adds a few non-function keywords and
  operators to the C<@Functions> array.

  All additions and modifications are welcome.


pkgId: e7824d4b7504d8f0df632284efad331c041207dc
name: local-perl-Backcountry-Config
arch: src
version: 1
epoch: 0
release: 1
summary: Backcountry::Config - cross-environment glue module
url: http://www.endpoint.com/
rpm_license: Artistic
rpm_vendor: End Point Corporation
rpm_group: Applications/Web
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: End Point Hosting <hosting@endpoint.com>
location_href: local-perl-Backcountry-Config-1-1.src.rpm
checksum_type: sha
description:
  This package provides the glue for Perl code to detect its place in camp, qa,
  staging, or production environments.


pkgId: ce6c29d86a038718eb9127ed94958e06aadfa9d9
name: local-perl-Barcode-Code128
arch: src
version: 2.01
epoch: 0
release: 1
summary: Barcode-Code128 - Generate CODE 128 bar codes
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: William R Ward <wrw@bayview.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Barcode-Code128-2.01-1.src.rpm
checksum_type: sha
description:
  Barcode::Code128 generates bar codes using the CODE 128 symbology.  It
  can generate images in PNG or GIF format using the GD package, or it
  can generate a text string representing the barcode that you can
  render using some other technology if desired.

  The intended use of this module is to create a web page with a bar
  code on it, which can then be printed out and faxed or mailed to
  someone who will scan the bar code.  The application which spurred its
  creation was an expense report tool, where the employee submitting the
  report would print out the web page and staple the receipts to it, and
  the Accounts Payable clerk would scan the bar code to indicate that
  the receipts were received.

  The default settings for this module produce a large image that can
  safely be FAXed several times and still scanned easily.  If this
  requirement is not important you can generate smaller image using
  optional parameters, described below.

  If you wish to generate images with this module you must also have the
  GD.pm module (written by Lincoln Stein, and available from CPAN)
  installed.  Version 1.20 or higher of GD generates a PNG file, due to
  issues with the GIF patent.  If you want to create a GIF, you must use
  version 1.19 or earlier of GD.  However, most browsers have no trouble
  with PNG files.

  If the GD module is not present, you can still use the module, but you
  will not be able to use its functions for generating images.  You can
  use the barcode() method to get a string of "#" and " " (hash and
  space) characters, and use your own image-generating routine with that
  as input.

  To use the the GD module, you will need to install it along with this
  module.  You can obtain it from the CPAN (Comprehensive Perl Archive
  Network) repository of your choice under the directory
  C<authors/id/LDS>.  Visit http://www.cpan.org/ for more information
  about CPAN.  The GD home page is:
  http://stein.cshl.org/WWW/software/GD/GD.html


pkgId: d2bfc7e0358f4012da0a4ac5b580b4538c9329ac
name: local-perl-Bundle-InterchangeKitchenSink
arch: src
version: 1.06
epoch: 0
release: 1
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: mikeh@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Bundle-InterchangeKitchenSink-1.06-1.src.rpm
checksum_type: sha
summary:
  Bundle-InterchangeKitchenSink - A bundle of most all the modules nice to have for Interchange. A lot of stuff.

description:
  This bundle installs the prerequisites for Interchange 5 as well as some
  modules that are not strictly necessary.

  (Interchange was formerly known as Minivend.)

  After installing this bundle, it is recommended that you quit the current
  session and then run Interchange's C<makecat> program. That will give you the
  benefit of line completion and history.

  The core functions of Interchange I<will> run with a stock Perl, but
  to use some features of Interchange (like the administrative interface)
  you will need these modules.

  Archive::Tar
  Archive::Zip
  Bundle::LWP
  Business::UPS
  Compress::Zlib
  Crypt::SSLeay
  DBI
  Digest::MD5
  HTML::Tagset
  IO::Scalar
  Image::Size
  MIME::Base64
  OLE::Storage_Lite
  Parse::RecDescent
  SOAP::Lite
  Safe::Hole
  Spreadsheet::ParseExcel
  Spreadsheet::WriteExcel
  Storable
  Term::ReadKey
  Term::ReadLine::Perl
  Tie::ShadowHash
  Tie::Watch
  Time::HiRes
  URI::URL


pkgId: 37bcc567572cbedb0b317c4c91dc99acbc07e77f
name: local-perl-Bundle-InterchangeKitchenSink
arch: src
version: 1.06
epoch: 0
release: 2
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: End Point Corporation
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Bundle-InterchangeKitchenSink-1.06-2.src.rpm
checksum_type: sha
summary:
  Bundle-InterchangeKitchenSink - A bundle of most all the modules nice to have for Interchange. A lot of stuff.

description:
  This bundle installs the prerequisites for Interchange 5.6.0 as well as some
  modules that are not strictly necessary.


pkgId: 1df8002d0b3046863373373560b8d167b9f94ffb
name: local-perl-Bundle-LWP
arch: src
version: 5.810
epoch: 0
release: 1
summary: Bundle-LWP - install all libwww-perl related modules
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: cpan
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Bundle-LWP-5.810-1.src.rpm
checksum_type: sha
description:
  Bundle::LWP - installs all libwww-perl related modules

  Digest::MD5 - Needed to do Digest authentication
  HTML::HeadParser - To get the correct $res->base
  HTML::Parser - Need by HTML::HeadParser
  HTML::Tagset - Needed by HTML::Parser
  LWP - The reason why you need the modules above
  MIME::Base64 - Used in authentication headers
  Net::FTP 2.58 - If you want ftp://-support
  URI 1.10 - There are URIs everywhere


pkgId: 674bd43cd80251264bcb5f870caaf2c9f1005809
name: local-perl-Business-3DSecure
arch: src
version: 0.02
epoch: 0
release: 1
summary: Business-3DSecure - Perl extension for 3D Secure Credit Card Verification
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Clayton Cottingham <clayton@wintermarket.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Business-3DSecure-0.02-1.src.rpm
checksum_type: sha
description:
  This Module provide an interface to 3DSecure Authentication, it has been patterned of the Business::OnlinePayment module to provide an easy to understand interface


pkgId: 67ba08679fa1b83990a8ab0404846f2ca199a372
name: local-perl-Business-CreditCard
arch: src
version: 0.30
epoch: 0
release: 1
summary: Business-CreditCard - Validate/generate credit card checksums/names
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: MIT Media Lab <orwant@tpj.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Business-CreditCard-0.30-1.src.rpm
checksum_type: sha
description:
  These subroutines tell you whether a credit card number is
  self-consistent -- whether the last digit of the number is a valid
  checksum for the preceding digits.

  The validate() subroutine returns 1 if the card number provided passes
  the checksum test, and 0 otherwise.

  The cardtype() subroutine returns a string containing the type of
  card.  The list of possible return values is more comprehensive than it used
  to be, but additions are still most welcome.

  Possible return values are:

    VISA card
    MasterCard
    Discover card
    American Express card
    Diner's Club/Carte Blanche
    enRoute
    JCB
    BankCard
    Switch
    Solo
    China Union Pay
    Unknown

  "Not a credit card" is returned on obviously invalid data values.

  As of 0.30, cardtype() will accept a partial card masked with "x", "X', ".",
  "*" or "_".  Only the first 2-6 digits and the lenth are significant;
  whitespace and dashes are removed.  To recognize just Visa, MasterCard and
  Amex, you only need the first two digits; to recognize almost all cards
  except some Switch cards, you need the first four digits, and to recognize
  all cards including the remaining Switch cards, you need the first six
  digits.

  The generate_last_digit() subroutine computes and returns the last
  digit of the card given the preceding digits.  With a 16-digit card,
  you provide the first 15 digits; the subroutine returns the sixteenth.

  This module does I<not> tell you whether the number is on an actual
  card, only whether it might conceivably be on a real card.  To verify
  whether a card is real, or whether it's been stolen, or to actually process
  charges, you need a Merchant account.  See L<Business::OnlinePayment>.

  These subroutines will also work if you provide the arguments
  as numbers instead of strings, e.g. C<validate(5276440065421319)>.


pkgId: 5a1f3cd0c58c6b0edcf4e255e5aae339db70002e
name: local-perl-Business-CreditCard-Object
arch: src
version: 1.00
epoch: 0
release: 1
summary: Business-CreditCard-Object - a Credit Card object
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tony Bowden <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Business-CreditCard-Object-1.00-1.src.rpm
checksum_type: sha
description:
  This provides an OO interface around the Business::CreditCard module.
  You instantiate it with a card number, and can ask if it is valid, for
  a standardised version of the card number, and what type of card it is.


pkgId: 224ea00ca873c8c46b6e1a8eb4a0ed03546b2d61
name: local-perl-Business-FedEx-DirectConnect
arch: src
version: 1.01
epoch: 0
release: 1
summary: Business-FedEx-DirectConnect - FedEx Ship Manager Direct Connect
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Jay Powers <jpowers@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Business-FedEx-DirectConnect-1.01-1.src.rpm
checksum_type: sha
description:
  This module provides the necessary means to send transactions to FedEx's
  Ship Manager Direct API.  Precautions have been taken to enforce FedEx's API guidelines
  to allow for all transaction types.

  This module is an alternative to using the FedEx Ship Manager API ATOM product.
  Business::FedEx::DirectConnect will provide the same communication using LWP and
  Crypt::SSLeay.

  The main advantage is you will no longer need to install the JRE dependant API
  provided by FedEx.  Instead, data is POST(ed) directly to the FedEx transaction servers.

  When using this module please keep in mind FedEx will occasionally change some of the
  transaction codes for their API.  This should not break existing code, but it is a good idea
  to check out changes when possible.  I document all the changes in a "Changes" log.


pkgId: cf55d11efea066ffb2b0ec53b371e3231caec8ff
name: local-perl-Business-OnlinePayment
arch: src
version: 3.00_09
epoch: 0
release: 1
summary: Business-OnlinePayment - Perl extension for online payment processing
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ivan Kohler <ivan-business-onlinepayment@420.am>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Business-OnlinePayment-3.00_09-1.src.rpm
checksum_type: sha
description:
  Business::OnlinePayment is a generic module for processing payments
  through online credit card processors, electronic cash systems, etc.


pkgId: 35272236df422afc2bf2a43f8686813ef374e82a
name: local-perl-Business-PayPal-API
arch: src
version: 0.61
epoch: 0
release: 1
summary: Business-PayPal-API - PayPal API
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Scott Wiersdorf <scott@perlcode.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Business-PayPal-API-0.61-1.src.rpm
checksum_type: sha
description:
  B<Business::PayPal::API> supports both certificate authentication and
  the new 3-token "Signature" authentication.

  It also support PayPal's development I<sandbox> for testing. See the
  B<sandbox> parameter to B<new()> below for details.

  B<Business::PayPal::API> can import other B<API> derived classes:

    use Business::PayPal::API qw( RefundTransaction );

  This allows for much more concise and intuitive usage. For example,
  these two statements are equivalent:

    use Business::PayPal::API::RefundTransaction;
    my $pp = new Business::PayPal::API::RefundTransaction( ... );
    $pp->RefundTransaction( ... );

  and more concisely:

    use Business::PayPal::API qw( RefundTransaction );
    my $pp = new Business::PayPal::API( ... );
    $pp->RefundTransaction( ... );

  The advantage of this becomes clear when you need to use multiple API
  calls in your program; this allows you to use the same object to
  invoke the various methods, instead of creating a new object for each
  subclass. Here is an example of a B<API> object used to invoke various
  PayPal APIs with the same object:

    use Business::PayPal::API qw( GetTransactionDetails
                                  TransactionSearch
                                  RefundTransaction );
    my $pp = new Business::PayPal::API( ... );
    my $records = $pp->TransactionSearch( ... );

    my %details = $pp->GetTransactionDetails( ... );

    my %resp = $pp->RefundTransaction( ... );

  However, you may certainly use just the subclass if that's all you
  need. Every subclass should work as its own self-contained API.

  For details on B<Business::PayPal::API::*> subclasses, see each
  subclass's individual documentation.


pkgId: 982922602277c63e3eb870f829a20344c01ddb37
name: local-perl-Business-Shipping-DataFiles
arch: src
version: 1.02
epoch: 0
release: 1
summary: Business-Shipping-DataFiles - Offline rate tables for Business::Shipping
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Dan Browning <db@kavod.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Business-Shipping-DataFiles-1.02-1.src.rpm
checksum_type: sha
description:
  To use any of the Business::Shipping offline cost estimation methods, this
  module is required.  It installs all of the rate tables that Business::Shipping
  relies on.  It is stored in a separate module because it is updated less
  frequently than Business::Shipping.


pkgId: 1f2ff0fb2f9b1016e5d28dee41d2ace9cb0f18ad
name: local-perl-Business-UPS
arch: src
version: 2.00
epoch: 0
release: 1
summary: Business-UPS - A UPS Interface Module
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Justin Wheeler <upsmodule@datademons.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Business-UPS-2.00-1.src.rpm
checksum_type: sha
description:
  A way of sending four arguments to a module to get shipping charges
  that can be used in, say, a CGI.


pkgId: a7ce373985ef51d39fffcf839c444cefcee65856
name: local-perl-CGI-Compile
arch: src
version: 0.15
epoch: 0
release: 1
summary: CGI-Compile - Compile .cgi scripts to a code reference like ModPerl::Registry
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tatsuhiko Miyagawa <miyagawa@bulknews.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-CGI-Compile-0.15-1.src.rpm
checksum_type: sha
description:
  CGI::Compile is an utility to compile CGI scripts into a code
  reference that can run many times on its own namespace, as long as the
  script is ready to run on a persistent environment.

  B<NOTE:> for best results, load L<CGI::Compile> before any modules used by your
  CGIs.


pkgId: d0de805083a5208ada15b8bedc5274434e6aa699
name: local-perl-CGI-Emulate-PSGI
arch: src
version: 0.14
epoch: 0
release: 1
summary: CGI-Emulate-PSGI - PSGI adapter for CGI
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tokuhiro Matsuno <tokuhirom@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-CGI-Emulate-PSGI-0.14-1.src.rpm
checksum_type: sha
description:
  This module allows an application designed for the CGI environment to
  run in a PSGI environment, and thus on any of the backends that PSGI
  supports.

  It works by translating the environment provided by the PSGI
  specification to one expected by the CGI specification. Likewise, it
  captures output as it would be prepared for the CGI standard, and
  translates it to the format expected for the PSGI standard using
  L<CGI::Parse::PSGI> module.


pkgId: d5d99c841488378f6f4650cc5e4727be891ef728
name: local-perl-CSS
arch: src
version: 1.08
epoch: 0
release: 1
summary: CSS - Object oriented access to Cascading Style Sheets (CSS)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Allen Day <allenday@ucla.edu>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-CSS-1.08-1.src.rpm
checksum_type: sha
description:
  This module can be used, along with a CSS::Parse::* module, to parse
  CSS data and represent it as a tree of objects. Using a CSS::Adaptor::*
  module, the CSS data tree can then be transformed into other formats.


pkgId: 0565ffb57021b9372386f231b9ed05b7710f227a
name: local-perl-CSS-Squish
arch: src
version: 0.07
epoch: 0
release: 1
summary: CSS-Squish - Compact many CSS files into one big file
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Thomas Sibley <trs@bestpractical.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-CSS-Squish-0.07-1.src.rpm
checksum_type: sha
description:
  This module takes a list of CSS files and concatenates them, making sure
  to honor any valid @import statements included in the files.

  Following the CSS 2.1 spec, @import statements must be the first rules in
  a CSS file.  Media-specific @import statements will be honored by enclosing
  the included file in an @media rule.  This has the side effect of actually
  I<improving> compatibility in Internet Explorer, which ignores
  media-specific @import rules but understands @media rules.

  It is possible that future versions will include methods to compact
  whitespace and other parts of the CSS itself, but this functionality
  is not supported at the current time.


pkgId: 65fe74da6f895c8632defced3a862d58e29922fc
name: local-perl-Cache
arch: src
version: 2.04
epoch: 0
release: 1
summary: Cache - the Cache interface
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Chris Leishman <chris@leishman.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Cache-2.04-1.src.rpm
checksum_type: sha
description:
  The Cache modules are designed to assist a developer in persisting data for a
  specified period of time.  Often these modules are used in web applications to
  store data locally to save repeated and redundant expensive calls to remote
  machines or databases.

  The Cache interface is implemented by derived classes that store cached data
  in different manners (such as as files on a filesystem, or in memory).


pkgId: 2bbdf25f72015ac46080b8abbf285d79c6515bac
name: local-perl-Cache-Cache
arch: src
version: 1.05
epoch: 0
release: 1
summary: Cache-Cache - - the Cache interface.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: author DeWitt Clinton <dewitt@unto.net>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Cache-Cache-1.05-1.src.rpm
checksum_type: sha
description:
  The Cache modules are designed to assist a developer in persisting
  data for a specified period of time.  Often these modules are used in
  web applications to store data locally to save repeated and redundant
  expensive calls to remote machines or databases.  People have also
  been known to use Cache::Cache for its straightforward interface in
  sharing data between runs of an application or invocations of a
  CGI-style script or simply as an easy to use abstraction of the
  filesystem or shared memory.

  The Cache::Cache interface is implemented by classes that support the
  get, set, remove, size, purge, and clear instance methods and their
  corresponding static methods for persisting data across method calls.


pkgId: 2c7059273641a1e85bf603ce760123333fcef04a
name: local-perl-Cache-FastMmap
arch: src
version: 1.28
epoch: 0
release: 1
summary: Cache-FastMmap - Uses an mmap'ed file to act as a shared memory interprocess cache
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Rob Mueller <cpan@robm.fastmail.fm>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Cache-FastMmap-1.28-1.src.rpm
checksum_type: sha
description:
  In multi-process environments (eg mod_perl, forking daemons, etc),
  it's common to want to cache information, but have that cache
  shared between processes. Many solutions already exist, and may
  suit your situation better:

  =over 4

  =item *

  L<MLDBM::Sync> - acts as a database, data is not automatically
  expired, slow

  =item *

  L<IPC::MM> - hash implementation is broken, data is not automatically
  expired, slow

  =item *

  L<Cache::FileCache> - lots of features, slow

  =item *

  L<Cache::SharedMemoryCache> - lots of features, VERY slow. Uses
  IPC::ShareLite which freeze/thaws ALL data at each read/write

  =item *

  L<DBI> - use your favourite RDBMS. can perform well, need a
  DB server running. very global. socket connection latency

  =item *

  L<Cache::Mmap> - similar to this module, in pure perl. slows down
  with larger pages

  =item *

  L<BerkeleyDB> - very fast (data ends up mostly in shared memory
  cache) but acts as a database overall, so data is not automatically
  expired

  =back

  In the case I was working on, I needed:

  =over 4

  =item *

  Automatic expiry and space management

  =item *

  Very fast access to lots of small items

  =item *

  The ability to fetch/store many items in one go

  =back

  Which is why I developed this module. It tries to be quite
  efficient through a number of means:

  =over 4

  =item *

  Core code is written in C for performance

  =item *

  It uses multiple pages within a file, and uses Fcntl to only lock
  a page at a time to reduce contention when multiple processes access
  the cache.

  =item *

  It uses a dual level hashing system (hash to find page, then hash
  within each page to find a slot) to make most C<get()> calls O(1) and
  fast

  =item *

  On each C<set()>, if there are slots and page space available, only
  the slot has to be updated and the data written at the end of the used
  data space. If either runs out, a re-organisation of the page is
  performed to create new slots/space which is done in an efficient way

  =back

  The class also supports read-through, and write-back or write-through
  callbacks to access the real data if it's not in the cache, meaning that
  code like this:

    my $Value = $Cache->get($Key);
    if (!defined $Value) {
      $Value = $RealDataSource->get($Key);
      $Cache->set($Key, $Value)
    }

  Isn't required, you instead specify in the constructor:

    Cache::FastMmap->new(
      ...
      context => $RealDataSourceHandle,
      read_cb => sub { $_[0]->get($_[1]) },
      write_cb => sub { $_[0]->set($_[1], $_[2]) },
    );

  And then:

    my $Value = $Cache->get($Key);

    $Cache->set($Key, $NewValue);

  Will just work and will be read/written to the underlying data source as
  needed automatically.


pkgId: edb5edbd08cd8212c605587adf88f745c7ef5c16
name: local-perl-Cache-Memcached
arch: src
version: 1.24
epoch: 0
release: 1
summary: Cache-Memcached - client library for memcached (memory cache daemon)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Brad Fitzpatrick <brad@danga.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Cache-Memcached-1.24-1.src.rpm
checksum_type: sha
description:
  This is the Perl API for memcached, a distributed memory cache daemon.
  More information is available at:

    http://www.danga.com/memcached/


pkgId: 28e98fbed454f90cbdb5adee6fd3001b14a9722a
name: local-perl-Cache-Memcached-Fast
arch: src
version: 0.12
epoch: 0
release: 1
summary: Cache-Memcached-Fast - Perl client for B<memcached>, in C language
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tomash Brechko <tomash.brechko@gmail.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Cache-Memcached-Fast-0.12-1.src.rpm
checksum_type: sha
description:
  B<Cache::Memcahced::Fast> is a Perl client for B<memcached>, a memory
  cache daemon (L<http://www.danga.com/memcached/>).  Module core is
  implemented in C and tries hard to minimize number of system calls and
  to avoid any key/value copying for speed.  As a result, it has very
  low CPU consumption.

  API is largely compatible with L<Cache::Memcached|Cache::Memcached>,
  original pure Perl client, most users of the original module may start
  using this module by installing it and adding I<"::Fast"> to the old
  name in their scripts (see L</"Compatibility with Cache::Memcached">
  below for full details).


pkgId: 5dcee828b19d6246d3d3749d507ad0a44e6eab0d
name: local-perl-Carp-Assert
arch: src
version: 0.20
epoch: 0
release: 1
summary: Carp-Assert - executable comments
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michael G Schwern <schwern@pobox.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Carp-Assert-0.20-1.src.rpm
checksum_type: sha
description:
  =begin testing

  BEGIN {
      local %ENV = %ENV;
      delete @ENV{qw(PERL_NDEBUG NDEBUG)};
      require Carp::Assert;
      Carp::Assert->import;
  }

  local %ENV = %ENV;
  delete @ENV{qw(PERL_NDEBUG NDEBUG)};

  =end testing

      "We are ready for any unforseen event that may or may not
      occur."
          - Dan Quayle

  Carp::Assert is intended for a purpose like the ANSI C library
  assert.h.  If you're already familiar with assert.h, then you can
  probably skip this and go straight to the FUNCTIONS section.

  Assertions are the explict expressions of your assumptions about the
  reality your program is expected to deal with, and a declaration of
  those which it is not.  They are used to prevent your program from
  blissfully processing garbage inputs (garbage in, garbage out becomes
  garbage in, error out) and to tell you when you've produced garbage
  output.  (If I was going to be a cynic about Perl and the user nature,
  I'd say there are no user inputs but garbage, and Perl produces
  nothing but...)

  An assertion is used to prevent the impossible from being asked of
  your code, or at least tell you when it does.  For example:

  =for example begin

      
      sub my_sqrt {
          my($num) = shift;

          
          assert($num >= 0);

          return sqrt $num;
      }

  =for example end

  =for example_testing
  is( my_sqrt(4),  2,            'my_sqrt example with good input' );
  ok( !eval{ my_sqrt(-1); 1 },   '  and pukes on bad' );

  The assertion will warn you if a negative number was handed to your
  subroutine, a reality the routine has no intention of dealing with.

  An assertion should also be used as something of a reality check, to
  make sure what your code just did really did happen:

      open(FILE, $filename) || die $!;
      @stuff = <FILE>;
      @stuff = do_something(@stuff);

      
      assert(@stuff > 0);

  The assertion makes sure you have some @stuff at the end.  Maybe the
  file was empty, maybe do_something() returned an empty list... either
  way, the assert() will give you a clue as to where the problem lies,
  rather than 50 lines down at when you wonder why your program isn't
  printing anything.

  Since assertions are designed for debugging and will remove themelves
  from production code, your assertions should be carefully crafted so
  as to not have any side-effects, change any variables, or otherwise
  have any effect on your program.  Here is an example of a bad
  assertation:

      assert($error = 1 if $king ne 'Henry');  # Bad!

  It sets an error flag which may then be used somewhere else in your
  program. When you shut off your assertions with the $DEBUG flag,
  $error will no longer be set.

  Here's another example of B<bad> use:

      assert($next_pres ne 'Dan Quayle' or goto Canada);  # Bad!

  This assertion has the side effect of moving to Canada should it fail.
  This is a very bad assertion since error handling should not be
  placed in an assertion, nor should it have side-effects.

  In short, an assertion is an executable comment.  For instance, instead
  of writing this

      
      $life = begin_life();

  you'd replace the comment with an assertion which B<enforces> the comment.

      $life = begin_life();
      assert( $life =~ /!$/ );

  =for testing
  my $life = 'Whimper!';
  ok( eval { assert( $life =~ /!$/ ); 1 },   'life ends with a bang' );


pkgId: ab5f49197d7e4bcc2f498d9c7a8a09c33b063617
name: local-perl-Carp-Assert-More
arch: src
version: 1.12
epoch: 0
release: 1
summary: Carp-Assert-More - convenience wrappers around Carp::Assert
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: petdance@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Carp-Assert-More-1.12-1.src.rpm
checksum_type: sha
description:
  Carp::Assert::More is a set of wrappers around the L<Carp::Assert> functions
  to make the habit of writing assertions even easier.

  Everything in here is effectively syntactic sugar.  There's no technical
  reason to use

      assert_isa( $foo, 'HTML::Lint' );

  instead of

      assert( defined $foo );
      assert( ref($foo) eq 'HTML::Lint' );

  other than readability and simplicity of the code.

  My intent here is to make common assertions easy so that we as programmers
  have no excuse to not use them.


pkgId: 8bc3b29853c5f1f66ef4bc6bcc8f67652f43a909
name: local-perl-Carp-Clan
arch: src
version: 6.00
epoch: 0
release: 1
summary: Carp-Clan - Report errors from perspective of caller of a "clan" of modules
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Joshua ben Jore <jjore@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Carp-Clan-6.00-1.src.rpm
checksum_type: sha
description:
  This module is based on "C<Carp.pm>" from Perl 5.005_03. It has been
  modified to skip all package names matching the pattern given in
  the "use" statement inside the "C<qw()>" term (or argument list).

  Suppose you have a family of modules or classes named "Pack::A",
  "Pack::B" and so on, and each of them uses "C<Carp::Clan qw(^Pack::);>"
  (or at least the one in which the error or warning gets raised).

  Thus when for example your script "tool.pl" calls module "Pack::A",
  and module "Pack::A" calls module "Pack::B", an exception raised in
  module "Pack::B" will appear to have originated in "tool.pl" where
  "Pack::A" was called, and not in "Pack::A" where "Pack::B" was called,
  as the unmodified "C<Carp.pm>" would try to make you believe C<:-)>.

  This works similarly if "Pack::B" calls "Pack::C" where the
  exception is raised, etcetera.

  In other words, this blames all errors in the "C<Pack::*>" modules
  on the user of these modules, i.e., on you. C<;-)>

  The skipping of a clan (or family) of packages according to a pattern
  describing its members is necessary in cases where these modules are
  not classes derived from each other (and thus when examining C<@ISA>
  - as in the original "C<Carp.pm>" module - doesn't help).

  The purpose and advantage of this is that a "clan" of modules can work
  together (and call each other) and throw exceptions at various depths
  down the calling hierarchy and still appear as a monolithic block (as
  though they were a single module) from the perspective of the caller.

  In case you just want to ward off all error messages from the module
  in which you "C<use Carp::Clan>", i.e., if you want to make all error
  messages or warnings to appear to originate from where your module
  was called (this is what you usually used to "C<use Carp;>" for C<;-)>),
  instead of in your module itself (which is what you can do with a
  "die" or "warn" anyway), you do not need to provide a pattern,
  the module will automatically provide the correct one for you.

  I.e., just "C<use Carp::Clan;>" without any arguments and call "carp"
  or "croak" as appropriate, and they will automatically defend your
  module against all blames!

  In other words, a pattern is only necessary if you want to make
  several modules (more than one) work together and appear as though
  they were only one.


pkgId: 3281cfae38fb2430923a373efb726d1fc78a8013
name: local-perl-Class-Accessor
arch: src
version: 0.31
epoch: 0
release: 1
summary: Class-Accessor - Automated accessor generation
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Marty Pauley <marty+perl@kasei.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Accessor-0.31-1.src.rpm
checksum_type: sha
description:
  This module automagically generates accessors/mutators for your class.

  Most of the time, writing accessors is an exercise in cutting and
  pasting.  You usually wind up with a series of methods like this:

      sub name {
          my $self = shift;
          if(@_) {
              $self->{name} = $_[0];
          }
          return $self->{name};
      }

      sub salary {
          my $self = shift;
          if(@_) {
              $self->{salary} = $_[0];
          }
          return $self->{salary};
      }

    

  One for each piece of data in your object.  While some will be unique,
  doing value checks and special storage tricks, most will simply be
  exercises in repetition.  Not only is it Bad Style to have a bunch of
  repetitious code, but its also simply not lazy, which is the real
  tragedy.

  If you make your module a subclass of Class::Accessor and declare your
  accessor fields with mk_accessors() then you'll find yourself with a
  set of automatically generated accessors which can even be
  customized!

  The basic set up is very simple:

      package My::Class;
      use base qw(Class::Accessor);
      My::Class->mk_accessors( qw(foo bar car) );

  Done.  My::Class now has simple foo(), bar() and car() accessors
  defined.


pkgId: 5a3540cc292d1cde0eab51f55efae3a50338efb7
name: local-perl-Class-Accessor-Grouped
arch: src
version: 0.10010
epoch: 0
release: 1
summary: Class-Accessor-Grouped - Lets you build groups of accessors
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Matt S. Trout <mst@shadowcatsystems.co.uk>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Accessor-Grouped-0.10010-1.src.rpm
checksum_type: sha
description:
  This class lets you build groups of accessors that will call different
  getters and setters. The documentation of this module still requires a lot
  of work (B<< volunteers welcome >.> >>), but in the meantime you can refer to
  L<this post|http://lo-f.at/glahn/2009/08/WritingPowerfulAccessorsForPerlClasses.html>
  for more information.


pkgId: 135d3cde582fb411700e5afe12e50ddfc3700201
name: local-perl-Class-C3
arch: src
version: 0.25
epoch: 0
release: 1
summary: Class-C3 - A pragma to use the C3 method resolution order algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Stevan Little, <stevan@iinteractive.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-C3-0.25-1.src.rpm
checksum_type: sha
description:
  This is pragma to change Perl 5's standard method resolution order from depth-first left-to-right
  (a.k.a - pre-order) to the more sophisticated C3 method resolution order.

  B<NOTE:> YOU SHOULD NOT USE THIS MODULE DIRECTLY - The feature provided
  is integrated into perl version >= 5.9.5, and you should use L<MRO::Compat>
  instead, which will use the core implementation in newer perls, but fallback
  to using this implementation on older perls.


pkgId: d48faec119ad95e2e7bae21550850efc4f4e5716
name: local-perl-Class-Data-Inheritable
arch: src
version: 0.08
epoch: 0
release: 1
summary: Class-Data-Inheritable - Inheritable, overridable class data
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Original code by <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Data-Inheritable-0.08-1.src.rpm
checksum_type: sha
description:
  Class::Data::Inheritable is for creating accessor/mutators to class
  data.  That is, if you want to store something about your class as a
  whole (instead of about a single object).  This data is then inherited
  by your subclasses and can be overriden.

  For example:

    Pere::Ubu->mk_classdata('Suitcase');

  will generate the method Suitcase() in the class Pere::Ubu.

  This new method can be used to get and set a piece of class data.

    Pere::Ubu->Suitcase('Red');
    $suitcase = Pere::Ubu->Suitcase;

  The interesting part happens when a class inherits from Pere::Ubu:

    package Raygun;
    use base qw(Pere::Ubu);

    
    $suitcase = Raygun->Suitcase;

  Raygun inherits its Suitcase class data from Pere::Ubu.

  Inheritance of class data works analogous to method inheritance.  As
  long as Raygun does not "override" its inherited class data (by using
  Suitcase() to set a new value) it will continue to use whatever is set
  in Pere::Ubu and inherit further changes:

    
    Pere::Ubu->Suitcase('Blue');

  However, should Raygun decide to set its own Suitcase() it has now
  "overridden" Pere::Ubu and is on its own, just like if it had
  overriden a method:

    
    Raygun->Suitcase('Orange');

  Now that Raygun has overridden Pere::Ubu futher changes by Pere::Ubu
  no longer effect Raygun.

    
    Pere::Ubu->Suitcase('Samsonite');


pkgId: 99d10ba30d24c6bbd2a9c65601264b2390426a7f
name: local-perl-Class-Factory
arch: src
version: 1.06
epoch: 0
release: 1
summary: Class-Factory - Useful base class for factory classes
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Chris Winters <chris@cwinters.com
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Factory-1.06-1.src.rpm
checksum_type: sha
description:
  This is a simple module that factory classes can use to generate new
  types of objects on the fly, providing a consistent interface to
  common groups of objects.

  Factory classes are used when you have different implementations for
  the same set of tasks but may not know in advance what implementations
  you will be using. Configuration files are a good example of
  this. There are four basic operations you would want to do with any
  configuration: read the file in, lookup a value, set a value, write
  the file out. There are also many different types of configuration
  files, and you may want users to be able to provide an implementation
  for their own home-grown configuration format.

  With a factory class this is easy. To create the factory class, just
  subclass C<Class::Factory> and create an interface for your
  configuration serializer. C<Class::Factory> even provides a simple
  constructor for you. Here's a sample interface and our two built-in
  configuration types:

   package My::ConfigFactory;

   use strict;
   use base qw( Class::Factory );

   sub read  { die "Define read() in implementation" }
   sub write { die "Define write() in implementation" }
   sub get   { die "Define get() in implementation" }
   sub set   { die "Define set() in implementation" }

   __PACKAGE__->add_factory_type( ini  => 'My::IniReader' );
   __PACKAGE__->add_factory_type( perl => 'My::PerlReader' );

   1;

  And then users can add their own subclasses:

   package My::CustomConfig;

   use strict;
   use base qw( My::ConfigFactory );

   sub init {
       my ( $self, $filename, $params ) = @_;
       if ( $params->{base_url} ) {
           $self->read_from_web( join( '/', $params->{base_url}, $filename ) );
       }
       else {
           $self->read( $filename );
       }
       return $self;
   }

   sub read  { ... implementation to read a file ... }
   sub write { ... implementation to write a file ...  }
   sub get   { ... implementation to get a value ... }
   sub set   { ... implementation to set a value ... }

   sub read_from_web { ... implementation to read via http ... }

   

   My::ConfigFactory->add_factory_type( 'mytype' => __PACKAGE__ );

   1;

  (You may not wish to make your factory the same as your interface, but
  this is an abbreviated example.)

  So now users can use the custom configuration with something like:

   

   use strict;
   use My::ConfigFactory;
   use My::CustomConfig;   # this adds the factory type 'custom'...

   my $config = My::ConfigFactory->new( 'custom', 'myconf.dat' );
   print "Configuration is a: ", ref( $config ), "\n";

  Which prints:

   Configuration is a My::CustomConfig

  And they can even add their own:

   My::ConfigFactory->register_factory_type( 'newtype' => 'My::New::ConfigReader' );

  This might not seem like a very big win, and for small standalone
  applications probably isn't. But when you develop large applications
  the C<(add|register)_factory_type()> step will almost certainly be
  done at application initialization time, hidden away from the eyes of
  the application developer. That developer will only know that she can
  access the different object types as if they are part of the system.

  As you see in the example above implementation for subclasses is very
  simple -- just add C<Class::Factory> to your inheritance tree and you
  are done.


pkgId: 4d26106037dafca514ce3f729a51cbd6234e6dfd
name: local-perl-Class-Load
arch: src
version: 0.06
epoch: 0
release: 1
summary: Class-Load - a working (require "Class::Name") and more
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Shawn M Moore, C<< <sartak at bestpractical.com> >>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Load-0.06-1.src.rpm
checksum_type: sha
description:
  C<require EXPR> only accepts C<Class/Name.pm> style module names, not
  C<Class::Name>. How frustrating! For that, we provide
  C<load_class 'Class::Name'>.

  It's often useful to test whether a module can be loaded, instead of throwing
  an error when it's not available. For that, we provide
  C<try_load_class 'Class::Name'>.

  Finally, sometimes we need to know whether a particular class has been loaded.
  Asking C<%INC> is an option, but that will miss inner packages and any class
  for which the filename does not correspond to the package name. For that, we
  provide C<is_class_loaded 'Class::Name'>.


pkgId: dfb7f1e22c1329e7be6cd119be0d8f4e512bd7d3
name: local-perl-Class-Loader
arch: src
version: 2.03
epoch: 0
release: 1
summary: Class-Loader - Load modules and create objects on demand.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Vipul Ved Prakash <mail@vipul.net>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Loader-2.03-1.src.rpm
checksum_type: sha
description:
  Certain applications like to defer the decision to use a particular module
  till runtime. This is possible in perl, and is a useful trick in
  situations where the type of data is not known at compile time and the
  application doesn't wish to pre-compile modules to handle all types of
  data it can work with. Loading modules at runtime can also provide
  flexible interfaces for perl modules. Modules can let the programmer
  decide what modules will be used by it instead of hard-coding their names.

  Class::Loader is an inheritable class that provides a method, _load(),
  to load a module from disk and construct an object by calling its
  constructor. It also provides a way to map modules names and
  associated metadata with symbolic names that can be used in place of
  module names at _load().


pkgId: 6d0f590eb0afcb86988be96e2c67702cfa378996
name: local-perl-Class-MOP
arch: src
version: 1.12
epoch: 0
release: 1
summary: Class-MOP - A Meta Object Protocol for Perl 5
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Stevan Little <stevan@iinteractive.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-MOP-1.12-1.src.rpm
checksum_type: sha
description:
  This module is a fully functioning meta object protocol for the
  Perl 5 object system. It makes no attempt to change the behavior or
  characteristics of the Perl 5 object system, only to create a
  protocol for its manipulation and introspection.

  That said, it does attempt to create the tools for building a rich set
  of extensions to the Perl 5 object system. Every attempt has been made
  to abide by the spirit of the Perl 5 object system that we all know
  and love.

  This documentation is sparse on conceptual details. We suggest looking
  at the items listed in the L<SEE ALSO> section for more
  information. In particular the book "The Art of the Meta Object
  Protocol" was very influential in the development of this system.


pkgId: a8568c5f8dfd5a82c619cbd2a72bfb40cd17475d
name: local-perl-Class-MakeMethods
arch: src
version: 1.009
epoch: 0
release: 1
summary: Class-MakeMethods - Generate common types of methods
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Matthew Simon Cavalletto <simonm@cavalletto.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-MakeMethods-1.009-1.src.rpm
checksum_type: sha
description:
  The Class::MakeMethods framework allows Perl class developers to
  quickly define common types of methods. When a module C<use>s
  Class::MakeMethods or one of its subclasses, it can select from a
  variety of supported method types, and specify a name for each
  method desired. The methods are dynamically generated and installed
  in the calling package.

  Construction of the individual methods is handled by subclasses.
  This delegation approach allows for a wide variety of method-generation
  techniques to be supported, each by a different subclass. Subclasses
  can also be added to provide support for new types of methods.

  Over a dozen subclasses are available, including implementations of
  a variety of different method-generation techniques. Each subclass
  generates several types of methods, with some supporting their own
  open-eneded extension syntax, for hundreds of possible combinations
  of method types.


pkgId: 74c926f8aaf2efa8889ae6e0ed3c7c2ae526cbb6
name: local-perl-Class-Method-Modifiers
arch: src
version: 1.08
epoch: 0
release: 1
summary: Class-Method-Modifiers - provides Moose-like method modifiers
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Shawn M Moore, C<sartak@gmail.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Method-Modifiers-1.08-1.src.rpm
checksum_type: sha
description:
  Method modifiers are a convenient feature from the CLOS (Common Lisp Object
  System) world.

  In its most basic form, a method modifier is just a method that calls
  C<< $self->SUPER::foo(@_) >>. I for one have trouble remembering that exact
  invocation, so my classes seldom re-dispatch to their base classes. Very bad!

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

  One clear benefit of using C<Class::Method::Modifiers> is that you can define
  multiple modifiers in a single namespace. These separate modifiers don't need
  to know about each other. This makes top-down design easy. Have a base class
  that provides the skeleton methods of each operation, and have plugins modify
  those methods to flesh out the specifics.

  Parent classes need not know about C<Class::Method::Modifiers>. This means you
  should be able to modify methods in I<any> subclass. See
  L<Term::VT102::ZeroBased> for an example of subclassing with CMM.

  In short, C<Class::Method::Modifiers> solves the problem of making sure you
  call C<< $self->SUPER::foo(@_) >>, and provides a cleaner interface for it.

  As of version 1.00, C<Class::Method::Modifiers> is faster in some cases than
  L<Moose>. See C<benchmark/method_modifiers.pl> in the L<Moose> distribution.


pkgId: db9c5b737e1cfe29fc667900ae0dd2733bda8276
name: local-perl-Class-Method-Modifiers
arch: src
version: 2.04
epoch: 0
release: 1
summary: Class-Method-Modifiers - provides Moose-like method modifiers
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Shawn M Moore, C<sartak@gmail.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Method-Modifiers-2.04-1.src.rpm
checksum_type: sha
description:
  Method modifiers are a convenient feature from the CLOS (Common Lisp Object
  System) world.

  In its most basic form, a method modifier is just a method that calls
  C<< $self->SUPER::foo(@_) >>. I for one have trouble remembering that exact
  invocation, so my classes seldom re-dispatch to their base classes. Very bad!

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

  One clear benefit of using C<Class::Method::Modifiers> is that you can define
  multiple modifiers in a single namespace. These separate modifiers don't need
  to know about each other. This makes top-down design easy. Have a base class
  that provides the skeleton methods of each operation, and have plugins modify
  those methods to flesh out the specifics.

  Parent classes need not know about C<Class::Method::Modifiers>. This means you
  should be able to modify methods in I<any> subclass. See
  L<Term::VT102::ZeroBased> for an example of subclassing with CMM.

  In short, C<Class::Method::Modifiers> solves the problem of making sure you
  call C<< $self->SUPER::foo(@_) >>, and provides a cleaner interface for it.

  As of version 1.00, C<Class::Method::Modifiers> is faster in some cases than
  L<Moose>. See C<benchmark/method_modifiers.pl> in the L<Moose> distribution.

  C<Class::Method::Modifiers> also provides an additional "modifier" type,
  C<fresh>; see below.


pkgId: 062766ae9528b23db815e5e97d52ebce36a432ad
name: local-perl-Class-Singleton
arch: src
version: 1.4
epoch: 0
release: 1
summary: Class-Singleton - Base class for creating singleton objects
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andy Wardley <abw@wardley.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Singleton-1.4-1.src.rpm
checksum_type: sha
description:
  This is the C<Class::Singleton> module.  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.  This module implements a
  Singleton class from which other classes can be derived.  By itself, the
  C<Class::Singleton> module does very little other than manage the instantiation
  of a single object.  In deriving a class from C<Class::Singleton>, your module
  will inherit the Singleton instantiation method and can implement whatever
  specific functionality is required.

  For a description and discussion of the Singleton class, see
  "Design Patterns", Gamma et al, Addison-Wesley, 1995, ISBN 0-201-63361-2.


pkgId: 72684a1170da544161948759f2f3e892dd7ae9ed
name: local-perl-Class-Trigger
arch: src
version: 0.13
epoch: 0
release: 1
summary: Class-Trigger - Mixin to add / call inheritable triggers
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Tony Bowden <Elttony@kasei.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-Trigger-0.13-1.src.rpm
checksum_type: sha
description:
  Class::Trigger is a mixin class to add / call triggers (or hooks)
  that get called at some points you specify.


pkgId: 5396e48bf57c8441b772d35e1eea0da81ca03a65
name: local-perl-Class-XSAccessor
arch: src
version: 1.13
epoch: 0
release: 1
summary: Class-XSAccessor - Generate fast XS accessors without runtime compilation
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Steffen Mueller <smueller@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Class-XSAccessor-1.13-1.src.rpm
checksum_type: sha
description:
  Class::XSAccessor implements fast read, write and read/write accessors in XS.
  Additionally, it can provide predicates such as C<has_foo()> for testing
  whether the attribute C<foo> is defined in the object.
  It only works with objects that are implemented as ordinary hashes.
  L<Class::XSAccessor::Array> implements the same interface for objects
  that use arrays for their internal representation.

  Since version 0.10, the module can also generate simple constructors
  (implemented in XS). Simply supply the
  C<constructor =E<gt> 'constructor_name'> option or the
  C<constructors =E<gt> ['new', 'create', 'spawn']> option.
  These constructors do the equivalent of the following Perl code:

    sub new {
      my $class = shift;
      return bless { @_ }, ref($class)||$class;
    }

  That means they can be called on objects and classes but will not
  clone objects entirely. Parameters to C<new()> are added to the
  object.

  The XS accessor methods are between 3 and 4 times faster than typical
  pure-Perl accessors in some simple benchmarking.
  The lower factor applies to the potentially slightly obscure
  C<sub set_foo_pp {$_[0]-E<gt>{foo} = $_[1]}>, so if you usually
  write clear code, a factor of 3.5 speed-up is a good estimate.
  If in doubt, do your own benchmarking!

  The method names may be fully qualified. The example in the synopsis could
  have been written as C<MyClass::get_foo> instead
  of C<get_foo>. This way, methods can be installed in classes other
  than the current class. See also: the C<class> option below.

  By default, the setters return the new value that was set,
  and the accessors (mutators) do the same. This behaviour can be changed
  with the C<chained> option - see below. The predicates return a boolean.

  Since version 1.01, C<Class::XSAccessor> can generate extremely simple methods which
  just return true or false (and always do so). If that seems like a
  really superfluous thing to you, then consider a large class hierarchy
  with interfaces such as L<PPI>. These methods are provided by the C<true>
  and C<false> options - see the synopsis.


pkgId: 529e63ca730c2a636c67152afe807e0264406bc5
name: local-perl-Clone
arch: src
version: 0.29
epoch: 0
release: 1
summary: Clone - recursively copy Perl datatypes
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ray Finch <rdf@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Clone-0.29-1.src.rpm
checksum_type: sha
description:
  This module provides a clone() method which makes recursive
  copies of nested hash, array, scalar and reference types,
  including tied variables and objects.


  clone() takes a scalar argument and an optional parameter that
  can be used to limit the depth of the copy. To duplicate lists,
  arrays or hashes, pass them in by reference. e.g.

      my $copy = clone (\@array);

      

      my %copy = %;


  For a slower, but more flexible solution see Storable's dclone().


pkgId: 15d7b8ab8987380aaec98b48cf0fbdb8a383ef6e
name: local-perl-Clone-PP
arch: src
version: 1.02
epoch: 0
release: 1
summary: Clone-PP - Recursively copy Perl datatypes
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: evo@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Clone-PP-1.02-1.src.rpm
checksum_type: sha
description:
  This module provides a general-purpose clone function to make deep
  copies of Perl data structures. It calls itself recursively to copy
  nested hash, array, scalar and reference types, including tied
  variables and objects.

  The clone() function takes a scalar argument to copy. To duplicate
  arrays or hashes, pass them in by reference:

    my $copy = clone(\@array);    my @copy = @{ clone(\@array) };
    my $copy = clone(\%hash);     my %copy = %;

  The clone() function also accepts an optional second parameter that
  can be used to limit the depth of the copy. If you pass a limit of
  0, clone will return the same value you supplied; for a limit of
  1, a shallow copy is constructed; for a limit of 2, two layers of
  copying are done, and so on.

    my $shallow_copy = clone( $item, 1 );

  To allow objects to intervene in the way they are copied, the
  clone() function checks for a couple of optional methods. If an
  object provides a method named C<clone_self>, it is called and the
  result returned without further processing. Alternately, if an
  object provides a method named C<clone_init>, it is called on the
  copied object before it is returned.


pkgId: dd4da046ddaf446d8dc3613ee76ae7d30dda7549
name: local-perl-Coat
arch: src
version: 0.334
epoch: 0
release: 1
summary: Coat - Light meta class for writing Moose compatible code
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Alexis Sukrieh <Eltsukria+perl@sukria.netEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Coat-0.334-1.src.rpm
checksum_type: sha
description:
  This module was inspired by the excellent C<Moose> meta class which provides
  enhanced object creation for Perl5.

  Moose is great, but has huge dependencies which makes it difficult to
  use in restricted environments.

  This module implements the basic goodness of Moose, namely accessors
  automagic, hook modifiers and inheritance facilities.

  B<It is not Moose> but the small bunch of features provided are
  B<Moose-compatible>. That means you can start with Coat and, if later you
  get to the point where you can or want to upgrade to Moose, your code won't
  have to change : every features provided by Coat exist in the Moose's API (but
  the opposite is not true, as you can imagine).


pkgId: 9d377c1bac8a0458d76cb8b261eee2f8bb58c4f9
name: local-perl-Compress-Raw-Bzip2
arch: src
version: 2.015
epoch: 0
release: 1
summary: Compress-Raw-Bzip2 - Low-Level Interface to bzip2 compression library
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Paul Marquess <pmqs@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Compress-Raw-Bzip2-2.015-1.src.rpm
checksum_type: sha
description:
  C<Compress::Raw::Bzip2> provides an interface to the in-memory
  compression/uncompression functions from the bzip2 compression library.

  Although the primary purpose for the existence of C<Compress::Raw::Bzip2>
  is for use by the  C<IO::Compress::Bzip2> and C<IO::Compress::Bunzip2>
  modules, it can be used on its own for simple compression/uncompression
  tasks.


pkgId: 2d2e4f710d84ab1936fc554e26710ad9415408cd
name: local-perl-Compress-Raw-Zlib
arch: src
version: 2.012
epoch: 0
release: 1
summary: Compress-Raw-Zlib - Low-Level Interface to zlib compression library
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Paul Marquess <pmqs@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Compress-Raw-Zlib-2.012-1.src.rpm
checksum_type: sha
description:
  The *Compress::Raw::Zlib* module provides a Perl interface to the *zlib*
  compression library (see "AUTHOR" for details about where to get
  *zlib*).


pkgId: fc8c7ca70d31054961f66defa4cbc5143193b2c0
name: local-perl-Config-Any
arch: src
version: 0.20
epoch: 0
release: 1
summary: Config-Any - Load configuration from different file formats, transparently
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Joel Bernstein <rataxis@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Config-Any-0.20-1.src.rpm
checksum_type: sha
description:
  L<Config::Any|Config::Any> provides a facility for Perl applications and libraries
  to load configuration data from multiple different file formats. It supports XML, YAML,
  JSON, Apache-style configuration, Windows INI files, and even Perl code.

  The rationale for this module is as follows: Perl programs are deployed on many different
  platforms and integrated with many different systems. Systems administrators and end
  users may prefer different configuration formats than the developers. The flexibility
  inherent in a multiple format configuration loader allows different users to make
  different choices, without generating extra work for the developers. As a developer
  you only need to learn a single interface to be able to use the power of different
  configuration formats.


pkgId: dd9c2c94938bc1103bf3ba65a5dee5ee1e87becc
name: local-perl-Config-Crontab
arch: src
version: 1.30
epoch: 0
release: 1
summary: Config-Crontab - Read/Write Vixie compatible crontab(5) files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Scott Wiersdorf <scott@perlcode.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build32
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Config-Crontab-1.30-1.src.rpm
checksum_type: sha
description:
  B<Config::Crontab> provides an object-oriented interface to
  Vixie-style crontab(5) files for Perl.

  A B<Config::Crontab> object allows you to manipulate an ordered set
  of B<Event>, B<Env>, or B<Comment> objects (also included with this
  package). Descriptions of these packages may be found below.

  In short, B<Config::Crontab> reads and writes crontab(5) files (and
  does a little pretty-printing too) using objects. The general idea is
  that you create a B<Config::Crontab> object and associate it with a
  file (if unassociated, it will work over a pipe to C<crontab -l>). From
  there, you can add lines to your crontab object, change existing line
  attributes, and write everything back to file.

  =over 4

  =item

  NOTE: B<Config::Crontab> does I<not> (currently) do validity checks
  on your data (i.e., dates out of range, etc.). However, if the call
  to B<crontab> fails when you invoke B<write>, B<write> will return
  I<undef> and set B<error> with the error message returned from the
  B<crontab> command. Future development may tend toward more validity
  checks.

  =back

  Now, to successfully navigate the module's ins and outs, we'll need a
  little terminology lesson.


pkgId: 326bb670d514e1492514cced1ce95e70ea93ed6a
name: local-perl-Config-General
arch: src
version: 2.4
epoch: 0
release: 1
summary: Config-General - Generic Config Module
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Thomas Linden tlinden <>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Config-General-2.4-1.src.rpm
checksum_type: sha
description:
  This module opens a config file and parses it's contents for you. The B<new> method
  requires one parameter which needs to be a filename. The method B<getall> returns a hash
  which contains all options and it's associated values of your config file.

  The format of config files supported by B<Config::General> is inspired by the well known apache config
  format, in fact, this module is 100% compatible to apache configs, but you can also just use simple
  name/value pairs in your config files.

  In addition to the capabilities of an apache config file it supports some enhancements such as here-documents,
  C-style comments or multiline options.


pkgId: 8fdc87e1efb29981fc39037b93e1ec77472d805f
name: local-perl-Config-IniFiles
arch: src
version: 2.38
epoch: 0
release: 1
summary: Config-IniFiles - A module for reading .ini-style configuration files.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: beJeremy Wadsack <dgsupport@wadsack-allen>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Config-IniFiles-2.38-1.src.rpm
checksum_type: sha
description:
  Config::IniFiles provides a way to have readable configuration files outside
  your Perl script.  Configurations can be imported (inherited, stacked,...),
  sections can be grouped, and settings can be accessed from a tied hash.


pkgId: 33fb29a21b0ad463d7f725312d74cb551ea7e6fd
name: local-perl-ConfigReader-Simple
arch: src
version: 1.28
epoch: 0
release: 1
summary: ConfigReader-Simple - Simple configuration file parser
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: brian d foy <bdfoy@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-ConfigReader-Simple-1.28-1.src.rpm
checksum_type: sha
description:
  C<ConfigReader::Simple> reads and parses simple configuration files. It is
  designed to be smaller and simpler than the C<ConfigReader> module
  and is more suited to simple configuration files.


pkgId: ea642ce9cc0824fe73b6364e0c542583b128c185
name: local-perl-Context-Preserve
arch: src
version: 0.01
epoch: 0
release: 1
description: None.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: AND COPYRIGHT
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Context-Preserve-0.01-1.src.rpm
checksum_type: sha
summary:
  Context-Preserve - run code after a subroutine call, preserving the context the subroutine would have seen if it were the last statement in the caller


pkgId: 0051ab5e539bf05cbad1c422c6b562741328084f
name: local-perl-Convert-ASCII-Armour
arch: src
version: 1.4
epoch: 0
release: 1
summary: Convert-ASCII-Armour - Convert binary octets into ASCII armoured messages.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Vipul Ved Prakash <mail@vipul.net>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Convert-ASCII-Armour-1.4-1.src.rpm
checksum_type: sha
description:
  This module converts hashes of binary octets into ASCII messages suitable
  for transfer over 6-bit clean transport channels. The encoded ASCII
  resembles PGP's armoured messages, but are in no way compatible with PGP.


pkgId: 76a66504c257730b71ebba46b4d797c6dd8f4f5c
name: local-perl-Convert-BinHex
arch: src
version: 1.119
epoch: 0
release: 1
summary: Convert-BinHex - extract data from Macintosh BinHex files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Eryq Fhttpwwwenteractcomeryq <Feryq@enteract.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Convert-BinHex-1.119-1.src.rpm
checksum_type: sha
description:
  B<BinHex> is a format used by Macintosh for transporting Mac files
  safely through electronic mail, as short-lined, 7-bit, semi-compressed
  data streams.  Ths module provides a means of converting those
  data streams back into into binary data.


pkgId: ae44daa556596a01c3663992c855c4f3de195f32
name: local-perl-Crypt-Blowfish
arch: src
version: 2.10
epoch: 0
release: 1
summary: Crypt-Blowfish - Perl Blowfish encryption module
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: dparis@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-Blowfish-2.10-1.src.rpm
checksum_type: sha
description:
  Blowfish is capable of strong encryption and can use key sizes up
  to 56 bytes (a 448 bit key).  You're encouraged to take advantage
  of the full key size to ensure the strongest encryption possible
  from this module.

  Crypt::Blowfish has the following methods:

  =over 4

   blocksize()
   keysize()
   encrypt()
   decrypt()

  =back


pkgId: 1c3427ee3590ca0f5fd57999d72ad994343ec00f
name: local-perl-Crypt-CBC
arch: src
version: 2.29
epoch: 0
release: 1
summary: Crypt-CBC - Encrypt Data with Cipher Block Chaining Mode
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Lincoln Stein <lstein@cshl.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-CBC-2.29-1.src.rpm
checksum_type: sha
description:
  This module is a Perl-only implementation of the cryptographic cipher
  block chaining mode (CBC).  In combination with a block cipher such as
  DES or IDEA, you can encrypt and decrypt messages of arbitrarily long
  length.  The encrypted messages are compatible with the encryption
  format used by the B<OpenSSL> package.

  To use this module, you will first create a Crypt::CBC cipher object
  with new().  At the time of cipher creation, you specify an encryption
  key to use and, optionally, a block encryption algorithm.  You will
  then call the start() method to initialize the encryption or
  decryption process, crypt() to encrypt or decrypt one or more blocks
  of data, and lastly finish(), to pad and encrypt the final block.  For
  your convenience, you can call the encrypt() and decrypt() methods to
  operate on a whole data value at once.


pkgId: c63d541d31fe2eee3696d4eef5ec55c92551e5c5
name: local-perl-Crypt-DES
arch: src
version: 2.05
epoch: 0
release: 1
summary: Crypt-DES - Perl DES encryption module
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: dparis@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-DES-2.05-1.src.rpm
checksum_type: sha
description:
  The module implements the Crypt::CBC interface,
  which has the following methods

  =over 4

  =item blocksize
  =item keysize
  =item encrypt
  =item decrypt

  =back


pkgId: 107c52742c61aa38f2f74682265ee297ea70161e
name: local-perl-Crypt-DES_EDE3
arch: src
version: 0.01
epoch: 0
release: 1
summary: Crypt-DES_EDE3 - Triple-DES EDE encryption/decryption
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Benjamin Trott <ben@rhumba.pair.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-DES_EDE3-0.01-1.src.rpm
checksum_type: sha
description:
  I<Crypt::DES_EDE3> implements DES-EDE3 encryption. This is triple-DES
  encryption where an encrypt operation is encrypt-decrypt-encrypt, and
  decrypt is decrypt-encrypt-decrypt. This implementation uses I<Crypt::DES>
  to do its dirty DES work, and simply provides a wrapper around that
  module: setting up the individual DES ciphers, initializing the keys,
  and performing the encryption/decryption steps.

  DES-EDE3 encryption requires a key size of 24 bytes.

  You're probably best off not using this module directly, as the I<encrypt>
  and I<decrypt> methods expect 8-octet blocks. You might want to use the
  module in conjunction with I<Crypt::CBC>, for example. This would be
  DES-EDE3-CBC, or triple-DES in outer CBC mode.


pkgId: a319129afaef6128a8d6c331d3f64cdf3f597ed6
name: local-perl-Crypt-DES_PP
arch: src
version: 1.00
epoch: 0
release: 1
summary: Crypt-DES_PP - Perl extension for DES encryption
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Guido Flohr <guido@imperia.net>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-DES_PP-1.00-1.src.rpm
checksum_type: sha
description:
  The Data Encryption Standard (DES), also known as Data Encryption
  Algorithm  (DEA) is a semi-strong encryption and decryption algorithm.

  The module is 100 % compatible to Crypt::DES but is implemented
  entirely in Perl.  That means that you do not need a C compiler to
  build and install this extension.

  The module implements the Crypt::CBC interface.  You are encouraged
  to read the documentation for Crypt::CBC if you intend to use this
  module for Cipher Block Chaining.

  The minimum (and maximum) key size is 8 bytes.  Shorter keys will
  cause an exception, longer keys will get silently truncated.  Data
  is encrypted and decrypted in blocks of 8 bytes.

  The module implements the Ultra-Fast-Crypt (UFC) algorithm as found
  for example in the GNU libc.  On the Perl side a lot has been done
  in order to make the module as fast as possible (function inlining,
  use integer, ...).

  Note: For performance issues the source code for the module is
  first preprocessed by m4.  That means that you need an m4 macro
  processor in order to hack on the sources.  This is of no concern
  for you if you only want to use the module, the preprocessed output
  is always included in the distribution.


pkgId: 5784b4c2d0919381da9d54da279e3e04f7784edb
name: local-perl-Crypt-GPG
arch: src
version: 1.63
epoch: 0
release: 1
summary: Crypt-GPG - An Object Oriented Interface to GnuPG.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ashish Gulhati <crypt-gpg@neomailbox.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-GPG-1.63-1.src.rpm
checksum_type: sha
description:
  The Crypt::GPG module provides access to the functionality of the
  GnuPG (www.gnupg.org) encryption tool through an object oriented
  interface.

  It provides methods for encryption, decryption, signing, signature
  verification, key generation, key certification, export and
  import. Key-server access is on the todo list.

  This release of the module may create compatibility issues with
  previous versions. If you find any such problems, or any bugs or
  documentation errors, please do report them to
  crypt-gpg at neomailbox.com.


pkgId: 71817857b88ee9dcd0c47c634a16e7420dd416a6
name: local-perl-Crypt-OpenSSL-RSA
arch: src
version: 0.26
epoch: 0
release: 1
summary: Crypt-OpenSSL-RSA - RSA encoding and decoding, using the openSSL libraries
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ian Robertson <iroberts@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-OpenSSL-RSA-0.26-1.src.rpm
checksum_type: sha
description:
  Crypt::OpenSSL::RSA provides the ability to RSA encrypt strings which are
  somewhat shorter than the block size of a key.  It also allows for decryption,
  signatures and signature verification.

  I<NOTE>: Many of the methods in this package can croak, so use eval, or
  Error.pm's try/catch mechanism to capture errors.  Also, while some
  methods from earlier versions of this package return true on success,
  this (never documented) behavior is no longer the case.


pkgId: 02150283654b14c68cab96809dd8fbfdb79a724f
name: local-perl-Crypt-OpenSSL-Random
arch: src
version: 0.04
epoch: 0
release: 1
summary: Crypt-OpenSSL-Random - RSA encoding and decoding, using the openSSL libraries
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ian Robertson <iroberts@cpan.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-OpenSSL-Random-0.04-1.src.rpm
checksum_type: sha
description:
  Crypt::OpenSSL::Random provides the ability to seed and query the
  OpenSSL library's pseudo-random number generator


pkgId: b9f43759c8315acc9b9946367e05ef75c06f7f19
name: local-perl-Crypt-PasswdMD5
arch: src
version: 1.3
epoch: 0
release: 1
summary: Crypt-PasswdMD5 - Provides interoperable MD5-based crypt() functions
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Luis E. Muñoz <luismunoz@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-PasswdMD5-1.3-1.src.rpm
checksum_type: sha
description:
  the C<unix_md5_crypt()> provides a crypt()-compatible interface to the
  rather new MD5-based crypt() function found in modern operating systems.
  It's based on the implementation found on FreeBSD 2.2.[56]-RELEASE and
  contains the following license in it:

   "THE BEER-WARE LICENSE" (Revision 42):
   <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
   can do whatever you want with this stuff. If we meet some day, and you think
   this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp

  C<apache_md5_crypt()> provides a function compatible with Apache's
  C<.htpasswd> files. This was contributed by Bryan Hart <bryan@eai.com>.
  As suggested by William A. Rowe, Jr. <wrowe@lnd.com>, it is
  exported by default.

  For both functions, if a salt value is not supplied, a random salt will be
  generated.  Contributed by John Peacock <jpeacock@cpan.org>.


pkgId: f17b995f8ceb5366d045a03490529bcb092d8a7e
name: local-perl-Crypt-Primes
arch: src
version: 0.50
epoch: 0
release: 1
summary: Crypt-Primes - Provable Prime Number Generator suitable for Cryptographic Applications.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Vipul Ved Prakash <Eltmail@vipul.netEgt>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-Primes-0.50-1.src.rpm
checksum_type: sha
description:
  This module implements Ueli Maurer's algorithm for generating large
  I<provable> primes and secure parameters for public-key cryptosystems.  The
  generated primes are almost uniformly distributed over the set of primes of
  the specified bitsize and expected time for generation is less than the time
  required for generating a pseudo-prime of the same size with Miller-Rabin
  tests.  Detailed description and running time analysis of the algorithm can
  be found in Maurer's paper[1].

  Crypt::Primes is a pure perl implementation.  It uses Math::Pari for
  multiple precision integer arithmetic and number theoretic functions.
  Random numbers are gathered with Crypt::Random, a perl interface to
  /dev/u?random devices found on most modern Unix operating systems.


pkgId: 6254682a2dfcb0baf483c2b4e5d13da58707593a
name: local-perl-Crypt-RC4
arch: src
version: 2.02
epoch: 0
release: 1
summary: Crypt-RC4 - Perl implementation of the RC4 encryption algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Kurt Kincaid <sifukurt@yahoo.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-RC4-2.02-1.src.rpm
checksum_type: sha
description:
  A simple implementation of the RC4 algorithm, developed by RSA Security, Inc. Here is the description
  from RSA's website:

  RC4 is a stream cipher designed by Rivest for RSA Data Security (now RSA Security). It is a variable
  key-size stream cipher with byte-oriented operations. The algorithm is based on the use of a random
  permutation. Analysis shows that the period of the cipher is overwhelmingly likely to be greater than
  10100. Eight to sixteen machine operations are required per output byte, and the cipher can be
  expected to run very quickly in software. Independent analysts have scrutinized the algorithm and it
  is considered secure.

  Based substantially on the "RC4 in 3 lines of perl" found at http://www.cypherspace.org

  A major bug in v1.0 was fixed by David Hook (dgh@wumpus.com.au).  Thanks, David.


pkgId: f5181c7ecffa89c355463f1f52f92ad30926ec10
name: local-perl-Crypt-Random
arch: src
version: 1.25
epoch: 0
release: 1
summary: Crypt-Random - Cryptographically Secure, True Random Number Generator.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Vipul Ved Prakash <mail@vipul.net>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-Random-1.25-1.src.rpm
checksum_type: sha
description:
  Crypt::Random is an interface module to the /dev/random device found on
  most modern unix systems. It also interfaces with egd, a user space
  entropy gathering daemon, available for systems where /dev/random (or
  similar) devices are not available. When Math::Pari is installed,
  Crypt::Random can generate random integers of arbritary size of a given
  bitsize or in a specified interval.


pkgId: db92a7253e70acb94f79ca1303a144a06d10e2db
name: local-perl-Crypt-SSLeay
arch: src
version: 0.57_01
epoch: 0
release: 1
summary: Crypt-SSLeay - OpenSSL support for LWP
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David Landgren
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Crypt-SSLeay-0.57_01-1.src.rpm
checksum_type: sha
description:
  This document describes C<Crypt::SSLeay> version 0.57_01, released
  2008-02-18.

  This perl module provides support for the https protocol under LWP,
  to allow an C<LWP::UserAgent> object to perform GET, HEAD and POST
  requests. Please see LWP for more information on POST requests.

  The C<Crypt::SSLeay> package provides C<Net::SSL>, which is loaded
  by C<LWP::Protocol::https> for https requests and provides the
  necessary SSL glue.

  This distribution also makes following deprecated modules available:

    Crypt::SSLeay::CTX
    Crypt::SSLeay::Conn
    Crypt::SSLeay::X509

  Work on Crypt::SSLeay has been continued only to provide https
  support for the LWP (libwww-perl) libraries.


pkgId: 8c007abbbe745d20aeb3d96250ac54bce744ef22
name: local-perl-DBD-SQLite
arch: src
version: 1.14
epoch: 0
release: 1
summary: DBD-SQLite - Self Contained RDBMS in a DBI Driver
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Matt Sergeant <matt@sergeant.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DBD-SQLite-1.14-1.src.rpm
checksum_type: sha
description:
  SQLite is a public domain RDBMS database engine that you can find
  at http://www.hwaci.com/sw/sqlite/.

  Rather than ask you to install SQLite first, because SQLite is public
  domain, DBD::SQLite includes the entire thing in the distribution. So
  in order to get a fast transaction capable RDBMS working for your
  perl project you simply have to install this module, and B<nothing>
  else.

  SQLite supports the following features:

  =over 4

  =item Implements a large subset of SQL92

  See http://www.hwaci.com/sw/sqlite/lang.html for details.

  =item A complete DB in a single disk file

  Everything for your database is stored in a single disk file, making it
  easier to move things around than with DBD::CSV.

  =item Atomic commit and rollback

  Yes, DBD::SQLite is small and light, but it supports full transactions!

  =item Extensible

  User-defined aggregate or regular functions can be registered with the
  SQL parser.

  =back

  There's lots more to it, so please refer to the docs on the SQLite web
  page, listed above, for SQL details. Also refer to L<DBI> for details
  on how to use DBI itself.


pkgId: 95fb3f50b5d9e7f7a8a577b8904b1ceff40222a6
name: local-perl-DBD-SQLite
arch: src
version: 1.39
epoch: 0
release: 1
summary: DBD-SQLite - Self Contained SQLite RDBMS in a DBI Driver
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Adam Kennedy <adamk@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DBD-SQLite-1.39-1.src.rpm
checksum_type: sha
description:
  SQLite is a public domain file-based relational database engine that
  you can find at L<http://www.sqlite.org/>.

  B<DBD::SQLite> is a Perl DBI driver for SQLite, that includes
  the entire thing in the distribution.
  So in order to get a fast transaction capable RDBMS working for your
  perl project you simply have to install this module, and B<nothing>
  else.

  SQLite supports the following features:

  =over 4

  =item Implements a large subset of SQL92

  See L<http://www.sqlite.org/lang.html> for details.

  =item A complete DB in a single disk file

  Everything for your database is stored in a single disk file, making it
  easier to move things around than with L<DBD::CSV>.

  =item Atomic commit and rollback

  Yes, B<DBD::SQLite> is small and light, but it supports full transactions!

  =item Extensible

  User-defined aggregate or regular functions can be registered with the
  SQL parser.

  =back

  There's lots more to it, so please refer to the docs on the SQLite web
  page, listed above, for SQL details. Also refer to L<DBI> for details
  on how to use DBI itself. The API works like every DBI module does.
  However, currently many statement attributes are not implemented or
  are limited by the typeless nature of the SQLite database.


pkgId: 6010876400927ae019e9600d4bf3998b74b2f633
name: local-perl-DBD-mysql
arch: src
version: 4.007
epoch: 0
release: 1
summary: DBD-mysql - A MySQL driver for the Perl5 Database Interface (DBI)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Rudy Lippan <rlippan@remotelinux.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DBD-mysql-4.007-1.src.rpm
checksum_type: sha
description:
  B<DBD::mysql> is the Perl5 Database Interface driver for the MySQL
  database. In other words: DBD::mysql is an interface between the Perl
  programming language and the MySQL programming API that comes with
  the MySQL relational database management system. Most functions
  provided by this programming API are supported. Some rarely used
  functions are missing, mainly because noone ever requested
  them. :-)

  In what follows we first discuss the use of DBD::mysql,
  because this is what you will need the most. For installation, see the
  sections on L<INSTALLATION>, and L<WIN32 INSTALLATION>
  below. See L<EXAMPLE> for a simple example above.

  From perl you activate the interface with the statement

      use DBI;

  After that you can connect to multiple MySQL database servers
  and send multiple queries to any of them via a simple object oriented
  interface. Two types of objects are available: database handles and
  statement handles. Perl returns a database handle to the connect
  method like so:

    $dbh = DBI->connect("DBI:mysql:database=$db;host=$host",
  		      $user, $password, {RaiseError => 1});

  Once you have connected to a database, you can can execute SQL
  statements with:

    my $query = sprintf("INSERT INTO foo VALUES (%d, %s)",
  		      $number, $dbh->quote("name"));
    $dbh->do($query);

  See L<DBI(3)> for details on the quote and do methods. An alternative
  approach is

    $dbh->do("INSERT INTO foo VALUES (?, ?)", undef,
  	   $number, $name);

  in which case the quote method is executed automatically. See also
  the bind_param method in L<DBI(3)>. See L<DATABASE HANDLES> below
  for more details on database handles.

  If you want to retrieve results, you need to create a so-called
  statement handle with:

    $sth = $dbh->prepare("SELECT * FROM $table");
    $sth->execute();

  This statement handle can be used for multiple things. First of all
  you can retreive a row of data:

    my $row = $sth->fetchrow_hashref();

  If your table has columns ID and NAME, then $row will be hash ref with
  keys ID and NAME. See L<STATEMENT HANDLES> below for more details on
  statement handles.

  But now for a more formal approach:


pkgId: 00b24d18cc4de47c8ce8897749435a920ca512be
name: local-perl-DBI
arch: src
version: 1.607
epoch: 0
release: 1.ep
summary: A database access API for perl
url: http://dbi.perl.org/
rpm_license: GPL+ or Artistic
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Libraries
rpm_buildhost: rhel5-build32
rpm_packager: End Point hosting team <hosting@endpoint.com>
location_href: local-perl-DBI-1.607-1.ep.src.rpm
checksum_type: sha
description:
  DBI is a database access Application Programming Interface (API) for
  the Perl Language. The DBI API Specification defines a set of
  functions, variables and conventions that provide a consistent
  database interface independent of the actual database being used.


pkgId: d5e637e756608ae2449f7de244bfa450efc3dd41
name: local-perl-DBIx-DBSchema
arch: src
version: 0.36
epoch: 0
release: 1
summary: DBIx-DBSchema - Database-independent schema objects
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ivan Kohler <ivan-dbix-dbschema@420.am>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DBIx-DBSchema-0.36-1.src.rpm
checksum_type: sha
description:
  DBIx::DBSchema objects are collections of DBIx::DBSchema::Table objects and
  represent a database schema.

  This module implements an OO-interface to database schemas.  Using this module,
  you can create a database schema with an OO Perl interface.  You can read the
  schema from an existing database.  You can save the schema to disk and restore
  it in a different process.  You can write SQL CREATE statements statements for
  different databases from a single source.  In recent versions, you can
  transform one schema to another, adding any necessary new columns and tables
  (and, as of 0.33, indices).

  Currently supported databases are MySQL, PostgreSQL and SQLite.  Sybase and
  Oracle drivers are partially implemented.  DBIx::DBSchema will attempt to use
  generic SQL syntax for other databases.  Assistance adding support for other
  databases is welcomed.  See L<DBIx::DBSchema::DBD>, "Driver Writer's Guide and
  Base Class".


pkgId: 826cd5ec4e9a2ebe7c243168a54bdb5f31aaddab
name: local-perl-DBIx-Safe
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: DBIx::Safe - Safer access to your database through a DBI database handle
url: http://bucardo.org/dbix_safe/Safe.pm.html
rpm_license: BSD
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: local-perl-DBIx-Safe-1.2.5-1.src.rpm
checksum_type: sha
description:
  This module gives controlled, limited database access to an application,
  rather than simply passing it a raw database handle through DBI.


pkgId: 812f36e18c75f0b42e62f9268033db10f8593ac9
name: local-perl-Dancer
arch: src
version: 1.3095
epoch: 0
release: 1
summary: Dancer - A minimal-effort oriented web application framework
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Alexis Sukrieh <sukria@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Dancer-1.3095-1.src.rpm
checksum_type: sha
description:
  Dancer is a web application framework designed to be as effortless as possible
  for the developer, taking care of the boring bits as easily as possible, yet
  staying out of your way and letting you get on with writing your code.

  Dancer aims to provide the simplest way for writing web applications, and
  offers the flexibility to scale between a very simple lightweight web service
  consisting of a few lines of code in a single file, all the way up to a more
  complex fully-fledged web application with session support, templates for views
  and layouts, etc.

  If you don't want to write CGI scripts by hand, and find Catalyst too big or
  cumbersome for your project, Dancer is what you need.

  Dancer has few pre-requisites, so your Dancer webapps will be easy to deploy.

  Dancer apps can be used with a an embedded web server (great for easy testing),
  and can run under PSGI/Plack for easy deployment in a variety of webserver
  environments.


pkgId: c28d89e26c4deef93655ba3ac574f5aa21ff3369
name: local-perl-Dancer-Plugin-Database
arch: src
version: 1.81
epoch: 0
release: 1
summary: Dancer-Plugin-Database - easy database connections for Dancer applications
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David Precious <davidp@preshweb.co.uk>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Dancer-Plugin-Database-1.81-1.src.rpm
checksum_type: sha
description:
  Provides an easy way to obtain a connected DBI database handle by simply calling
  the database keyword within your L<Dancer> application

  Returns a L<Dancer::Plugin::Database::Handle> object, which is a subclass of
  L<DBI>'s C<DBI::db> connection handle object, so it does everything you'd expect
  to do with DBI, but also adds a few convenience methods.  See the documentation
  for L<Dancer::Plugin::Database::Handle> for full details of those.

  Takes care of ensuring that the database handle is still connected and valid.
  If the handle was last asked for more than C<connection_check_threshold> seconds
  ago, it will check that the connection is still alive, using either the
  C<< $dbh->ping >> method if the DBD driver supports it, or performing a simple
  no-op query against the database if not.  If the connection has gone away, a new
  connection will be obtained and returned.  This avoids any problems for
  a long-running script where the connection to the database might go away.

  Care is taken that handles are not shared across processes/threads, so this
  should be thread-safe with no issues with transactions etc.  (Thanks to Matt S
  Trout for pointing out the previous lack of thread safety.  Inspiration was
  drawn from DBIx::Connector.)


pkgId: bb80dfebafcea31d5dcbc391cf547edb66b631ae
name: local-perl-Data-Buffer
arch: src
version: 0.04
epoch: 0
release: 1
summary: Data-Buffer - Read/write buffer class
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Benjamin Trott <ben@rhumba.pair.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Buffer-0.04-1.src.rpm
checksum_type: sha
description:
  I<Data::Buffer> implements a low-level binary buffer in which
  you can get and put integers, strings, and other data.
  Internally the implementation is based on C<pack> and C<unpack>,
  such that I<Data::Buffer> is really a layer on top of those
  built-in functions.

  All of the I<get_*> and I<put_*> methods respect the
  internal offset state in the buffer object. This means that
  you should read data out of the buffer in the same order that
  you put it in. For example:

      $buf->put_int16(24);
      $buf->put_int32(1233455);
      $buf->put_int16(99);

      $buf->get_int16;   # 24
      $buf->get_int32;   # 1233455
      $buf->get_int16;   # 99

  Of course, this assumes that you I<know> the order of the data
  items in the buffer. If your setup is such that your sending
  and receiving processes won't necessarily know what's inside
  the buffers they receive, take a look at the I<TEMPLATE USAGE>
  section.


pkgId: a04d2f6deac4055d9f52b50fb500b6baaa895ac6
name: local-perl-Data-Compare
arch: src
version: 1.22
epoch: 0
release: 1
summary: Data-Compare - compare perl data structures
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Fabien Tassin <Eltfta@sofaraway.orgEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Compare-1.22-1.src.rpm
checksum_type: sha
description:
  Compare two perl data structures recursively. Returns 0 if the
  structures differ, else returns 1.

  A few data types are treated as special cases:

  =over 4

  =item Scalar::Properties objects

  This has been moved into a plugin, although functionality remains the
  same as with the previous version.  Full documentation is in
  L<Data::Compare::Plugins::Scalar::Properties>.

  =item Compiled regular expressions, eg qr/foo/

  These are stringified before comparison, so the following will match:

      $r = qr/abc/i;
      $s = qr/abc/i;
      Compare($r, $s);

  and the following won't, despite them matching *exactly* the same text:

      $r = qr/abc/i;
      $s = qr/[aA][bB][cC]/;
      Compare($r, $s);

  Sorry, that's the best we can do.

  =item CODE and GLOB references

  These are assumed not to match unless the references are identical - ie,
  both are references to the same thing.

  =back

  You may also customise how we compare structures by supplying options in
  a hashref as a third parameter to the C<Compare()> function.  This is not
  yet available through the OO-ish interface.  These options will be in
  force for the *whole* of your comparison, so will apply to structures
  that are lurking deep down in your data as well as at the top level, so
  beware!

  =over 4

  =item ignore_hash_keys

  an arrayref of strings. When comparing two hashes, any keys mentioned in
  this list will be ignored.

  =back


pkgId: 79ae447b0bf64637d05f98005719a9dc1478682e
name: local-perl-Data-Dump
arch: src
version: 1.08
epoch: 0
release: 1
summary: Data-Dump - Pretty printing of data structures
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Gisle Aas <gisle@aas.no,>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Dump-1.08-1.src.rpm
checksum_type: sha
description:
  This module provides a single function called dump() that takes a list
  of values as its argument and produces a string as its result.  The string
  contains Perl code that, when C<eval>ed, produces a deep copy of the
  original arguments.  The string is formatted for easy reading.

  If dump() is called in a void context, then the dump is printed on
  STDERR instead of being returned.

  If you don't like importing a function that overrides Perl's
  not-so-useful builtin, then you can also import the same function as
  pp(), mnemonic for "pretty-print".


pkgId: 93389b3f757de4e5cd9ffe68c4305ccb9c375713
name: local-perl-Data-Dump
arch: src
version: 1.17
epoch: 0
release: 1
summary: Data-Dump - Pretty printing of data structures
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Gisle Aas <gisle@activestate.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Dump-1.17-1.src.rpm
checksum_type: sha
description:
  This module provide a few functions that traverse their
  argument and produces a string as its result.  The string contains
  Perl code that, when C<eval>ed, produces a deep copy of the original
  arguments.

  The main feature of the module is that it strives to produce output
  that is easy to read.  Example:

      @a = (1, [2, 3], {4 => 5});
      dump(@a);

  Produces:

      "(1, [2, 3], { 4 => 5 })"

  If you dump just a little data, it is output on a single line. If
  you dump data that is more complex or there is a lot of it, line breaks
  are automatically added to keep it easy to read.

  The following functions are provided (only the dd* functions are exported by default):

  =over

  =item dump( ... )

  =item pp( ... )

  Returns a string containing a Perl expression.  If you pass this
  string to Perl's built-in eval() function it should return a copy of
  the arguments you passed to dump().

  If you call the function with multiple arguments then the output will
  be wrapped in parenthesis "( ..., ... )".  If you call the function with a
  single argument the output will not have the wrapping.  If you call the function with
  a single scalar (non-reference) argument it will just return the
  scalar quoted if needed, but never break it into multiple lines.  If you
  pass multiple arguments or references to arrays of hashes then the
  return value might contain line breaks to format it for easier
  reading.  The returned string will never be "\n" terminated, even if
  contains multiple lines.  This allows code like this to place the
  semicolon in the expected place:

     print '$obj = ', dump($obj), ";\n";

  If dump() is called in void context, then the dump is printed on
  STDERR and then "\n" terminated.  You might find this useful for quick
  debug printouts, but the dd*() functions might be better alternatives
  for this.

  There is no difference between dump() and pp(), except that dump()
  shares its name with a not-so-useful perl builtin.  Because of this
  some might want to avoid using that name.

  =item quote( $string )

  Returns a quoted version of the provided string.

  It differs from C<dump($string)> in that it will quote even numbers and
  not try to come up with clever expressions that might shorten the
  output.  If a non-scalar argument is provided then it's just stringified
  instead of traversed.

  =item dd( ... )

  =item ddx( ... )

  These functions will call dump() on their argument and print the
  result to STDOUT (actually, it's the currently selected output handle, but
  STDOUT is the default for that).

  The difference between them is only that ddx() will prefix the lines
  it prints with "# " and mark the first line with the file and line
  number where it was called.  This is meant to be useful for debug
  printouts of state within programs.

  =item dumpf( ..., \&filter )

  Short hand for calling the dump_filtered() function of L<Data::Dump::Filtered>.
  This works like dump(), but the last argument should be a filter callback
  function.  As objects are visited the filter callback is invoked and it
  can modify how the objects are dumped.

  =back


pkgId: d2456a40628ef887857a95bd5804b12becbcd1bd
name: local-perl-Data-Dump-Streamer
arch: src
version: 2.08.40
epoch: 0
release: 1
summary: Data-Dump-Streamer - Accurately serialize a data structure as Perl code.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Yves Orton (demerphq)
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Dump-Streamer-2.08.40-1.src.rpm
checksum_type: sha
description:
  Given a list of scalars or reference variables, writes out
  their contents in perl syntax. The references can also be
  objects. The contents of each variable is output using the least
  number of Perl statements as convenient, usually only one.
  Self-referential structures, closures, and objects are output
  correctly.

  The return value can be evaled to get back an identical copy
  of the original reference structure. In some cases this may
  require the use of utility subs that
  L<Data::Dump::Streamer|Data::Dump::Streamer> will optionally
  export.

  This module is very similar in concept to the core module
  L<Data::Dumper|Data::Dumper>, with the major differences
  being that this module is designed to output to a stream
  instead of constructing its output in memory (trading speed
  for memory), and that the traversal over the data structure
  is effectively breadth first versus the depth first
  traversal done by the others.

  In fact the data structure is scanned twice, first in
  breadth first mode to perform structural analysis, and then
  in depth first mode to actually produce the output, but
  obeying the depth relationships of the first pass.


pkgId: 996793e19a5fef4a92bad35953f3f49de359f34d
name: local-perl-Data-Dumper-Concise
arch: src
version: 2.020
epoch: 0
release: 1
summary: Data-Dumper-Concise - Less indentation and newlines plus sub deparsing
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: mst - Matt S. Trout <mst@shadowcat.co.uk>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Dumper-Concise-2.020-1.src.rpm
checksum_type: sha
description:
  This module always exports a single function, Dumper, which can be called
  with an array of values to dump those values.

  It exists, fundamentally, as a convenient way to reproduce a set of Dumper
  options that we've found ourselves using across large numbers of applications,
  primarily for debugging output.

  The principle guiding theme is "all the concision you can get while still
  having a useful dump and not doing anything cleverer than setting Data::Dumper
  options" - it's been pointed out to us that Data::Dump::Streamer can produce
  shorter output with less lines of code. We know. This is simpler and we've
  never seen it segfault. But for complex/weird structures, it generally rocks.
  You should use it as well, when Concise is underkill. We do.

  Why is deparsing on when the aim is concision? Because you often want to know
  what subroutine refs you have when debugging and because if you were planning
  to eval this back in you probably wanted to remove subrefs first and add them
  back in a custom way anyway. Note that this -does- force using the pure perl
  Dumper rather than the XS one, but I've never in my life seen Data::Dumper
  show up in a profile so "who cares?".


pkgId: ca41deb28cf4073b6797ad76df009fed600aa7a5
name: local-perl-Data-HashArray
arch: src
version: 1.0
epoch: 0
release: 1
summary: Data-HashArray - An array class of hashes that has magical properties via overloading and AUTOLOAD.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ayhan Ulusoy <dev@ulusoy.name>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build32
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-HashArray-1.0-1.src.rpm
checksum_type: sha
description:
  Normally, B<Data::HashArray> is an array of hashes or hash-based objects. This class has some magical properties
  that make it easier to deal with multiplicity.

  First, there exist two B<overload>s. One for hash access and the other for stringification. Both will act on the first
  element of the array. In other words, performing a hash access on an object of this class will be equivalent to
  performing a hash access on the first element of the array.

  Second, the AUTOLOAD method will delegate any method unkown to this class to the first item in the array as well. For this to
  work, at least the first item of the array better be an object on which one could call such a method.

  Both of these magical properties make it easier to deal with unpredictable multiplicity. You can both treat the object as an array
  or as hash (the first one in the array). This way, if your code deosn't know that an element can occur multiple times (in other words, if the
  code treats the element as singular), the same code should still largely work when the singualr element is replaced by a B<Data::HashArray> object.

  The other practical feature of this class is the capabality to place the objects (or hashes) in the array into a hash keyed on the value of a given field or fields
  (see the L</hash()> method for further details).


pkgId: 21affd93e76ec9223e46b88218c883765a5befc3
name: local-perl-Data-Hierarchy
arch: src
version: 0.34
epoch: 0
release: 1
summary: Data-Hierarchy - Handle inheritable attributes in a hierarchical environment.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Chia-liang Kao (clkao@clkao.org)
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Hierarchy-0.34-1.src.rpm
checksum_type: sha
description:
  L<Data::Hierarchy> provides a simple interface for manipulating
  inheritable data attached to a hierarchical environment (like
  a filesystem).

  One use of L<Data::Hierarchy> is to allow an application to annotate
  paths in a real filesystem in a single compact data
  structure. However, the hierarchy does not actually need to correspond
  to an actual filesystem.

  Paths in a hierarchy are referred to in a Unix-like syntax; C<"/"> is
  the root "directory". (You can specify a different separator character
  than the slash when you construct a Data::Hierarchy object.)  With the
  exception of the root path, paths should never contain trailing
  slashes. You can associate properties, which are arbitrary name/value
  pairs, with any path.  (Properties cannot contain the undefined value.)
  By default, properties are inherited by child
  paths: thus, if you store some data at C</some/path>:

      $tree->store('/some/path', {color => 'red'});

  you can fetch it again at a C</some/path/below/that>:

      print $tree->get('/some/path/below/that')->{'color'};
      

  On the other hand, properties whose names begin with dots are
  uninherited, or "sticky":

      $tree->store('/some/path', {'.color' => 'blue'});
      print $tree->get('/some/path')->{'.color'};            # prints blue
      print $tree->get('/some/path/below/that')->{'.color'}; # undefined

  Note that you do not need to (and in fact, cannot) explicitly add
  "files" or "directories" to the hierarchy; you simply add and delete
  properties to paths.


pkgId: 9bfcee8f5d20152bb6967872d2117d62d03b2679
name: local-perl-Data-PowerSet
arch: src
version: 0.05
epoch: 0
release: 1
summary: Data-PowerSet - Generate all subsets of a list of elements
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David Landgren
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-PowerSet-0.05-1.src.rpm
checksum_type: sha
description:
  C<Data::PowerSet> takes a list and returns all possible
  combinations of the elements appearing in the list without replacement.


pkgId: 9959104bd15ec5f6c5f50254d953da2be572c9de
name: local-perl-Data-Taxi
arch: src
version: 0.95
epoch: 0
release: 1
summary: Data-Taxi - Taint-aware, XML-ish data serialization
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Miko O'Sullivan <miko.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Taxi-0.95-1.src.rpm
checksum_type: sha
description:
  Taxi (B<T>aint-B<A>ware B<X>ML-B<I>sh) is a data serializer with several handy features:

  =over

  =item Taint aware

  Taxi does not force you to trust the data you are serializing.
  None of the input data is executed.

  =item Human readable

  Taxi produces a human-readable string that simplifies checking the
  output of your objects.

  =item XML-ish

  While I don't (currently) promise full XML compliance, Taxi produces a block
  of XML-ish data that could probably be read in by other XML parsers.

  =back


pkgId: 89f4e0f10135d0530ecd880f6e76f378384a9309
name: local-perl-Data-UUID
arch: src
version: 1.148
epoch: 0
release: 1
summary: Data-UUID - Perl extension for generating Globally/Universally
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ricardo Signes <rjbs[at]cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-UUID-1.148-1.src.rpm
checksum_type: sha
description:
  This module provides a framework for generating UUIDs (Universally Unique
  Identifiers, also known as GUIDs (Globally Unique Identifiers). A UUID is 128
  bits long, and is guaranteed to be different from all other UUIDs/GUIDs
  generated until 3400 CE.

  UUIDs were originally used in the Network Computing System (NCS) and later in
  the Open Software Foundation's (OSF) Distributed Computing Environment.
  Currently many different technologies rely on UUIDs to provide unique identity
  for various software components. Microsoft COM/DCOM for instance, uses GUIDs
  very extensively to uniquely identify classes, applications and components
  across network-connected systems.

  The algorithm for UUID generation, used by this extension, is described in the
  Internet Draft "UUIDs and GUIDs" by Paul J. Leach and Rich Salz
  (L<http://hegel.ittc.ku.edu/topics/internet/internet-drafts/draft-l/draft-leach-uuids-guids-01.txt>).
  It provides reasonably efficient and reliable framework for generating UUIDs
  and supports fairly high allocation rates -- 10 million per second per machine
  -- and therefore is suitable for identifying both extremely short-lived and
  very persistent objects on a given system as well as across the network.

  This modules provides several methods to create a UUID:

     
     $ug->create();
     $ug->create_bin();

     
     
     $ug->create_from_name(<namespace>, <name>);
     $ug->create_from_name_bin(<namespace>, <name>);

     
     
     $ug->create_str();
     $ug->create_from_name_str(<namespace>, <name>);

     
     
     $ug->create_hex();
     $ug->create_from_name_hex(<namespace>, <name>);

     
     $ug->create_b64();
     $ug->create_from_name_b64(<namespace>, <name>);

     Binary UUIDs can be converted to printable strings using following methods:

     
     $ug->to_string(<uuid>);

     
     $ug->to_hexstring(<uuid>);

     
     $ug->to_b64string(<uuid>);

     Conversly, string UUIDs can be converted back to binary form:

     
     $ug->from_string(<uuid>);
     $ug->from_hexstring(<uuid>);

     
     $ug->from_b64string(<uuid>);

     Finally, two binary UUIDs can be compared using the following method:

     
     
     $ug->compare(<uuid1>, <uuid2>);

  Examples:

     use Data::UUID qw(:all);

     
     

     $ug = new Data::UUID;
     print $ug->create_from_name_str(NameSpace_URL, "www.mycompany.com");


pkgId: 0cf6307e4d87822089ab0f8edb788e23edad9259
name: local-perl-Data-Visitor
arch: src
version: 0.27
epoch: 0
release: 1
summary: Data-Visitor - Visitor style traversal of Perl data structures
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Yuval Kogman C <nothingmuch@woobling.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Data-Visitor-0.27-1.src.rpm
checksum_type: sha
description:
  This module is a simple visitor implementation for Perl values.

  It has a main dispatcher method, C<visit>, which takes a single perl value and
  then calls the methods appropriate for that value.

  It can recursively map (cloning as necessary) or just traverse most structures,
  with support for per object behavior, circular structures, visiting tied
  structures, and all ref types (hashes, arrays, scalars, code, globs).

  L<Data::Visitor> is meant to be subclassed, but also ships with a callback
  driven subclass, L<Data::Visitor::Callback>.


pkgId: 8e3fbae99c5c23d83c7575d80171e93a015c6aaf
name: local-perl-Date-DayOfWeek
arch: src
version: 1.22
epoch: 0
release: 1
summary: Date-DayOfWeek - Determine the day of the week for any date.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Rich Bowen <rbowen@rcbowen.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Date-DayOfWeek-1.22-1.src.rpm
checksum_type: sha
description:
  Calculates the day of the week for any date in the Gregorian calendar
  (1563 and following).
  Based on the Doomsday algorithm of John Conway.


pkgId: 8b39e08ef8626383126068415a730aa807789575
name: local-perl-DateTime
arch: src
version: 0.4304
epoch: 1
release: 1
summary: Date and time objects
url: http://search.cpan.org/dist/DateTime/
rpm_license: GPL+ or Artistic
rpm_group: Development/Libraries
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: local-perl-DateTime-0.4304-1.src.rpm
checksum_type: sha
description:
  DateTime is a class for the representation of date/time combinations, and
  is part of the Perl DateTime project. For details on this project please
  see http://datetime.perl.org/. The DateTime site has a FAQ which may help
  answer many "how do I do X?" questions. The FAQ is at
  http://datetime.perl.org/?FAQ.


pkgId: aa6bc6fd49bf8daac9001bb08828571e278f7070
name: local-perl-DateTime-Event-ICal
arch: src
version: 0.09
epoch: 0
release: 1
summary: DateTime-Event-ICal - DateTime rfc2445 recurrences
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Flavio S. Glock <fglock@pucrs.br>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Event-ICal-0.09-1.src.rpm
checksum_type: sha
description:
  This module provides convenience methods that let you easily create
  C<DateTime::Set> objects for rfc2445 style recurrences.


pkgId: cbda681ac4abb1f6f0241c297ebb10b273a50222
name: local-perl-DateTime-Event-Recurrence
arch: src
version: 0.16
epoch: 0
release: 1
summary: DateTime-Event-Recurrence - DateTime base recurrences
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Flavio S. Glock <fglock@pucrs.br>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Event-Recurrence-0.16-1.src.rpm
checksum_type: sha
description:
  This module provides convenience methods that let you easily create
  C<DateTime::Set> objects for various recurrences, such as "once a
  month" or "every day".  You can also create more complicated
  recurrences, such as "every Monday, Wednesday and Thursday at 10:00 AM
  and 2:00 PM".


pkgId: 03fa26960a8e29cb84f05a0a17ae76851435096f
name: local-perl-DateTime-Format-CLDR
arch: src
version: 1.13
epoch: 0
release: 1
summary: DateTime-Format-CLDR - Parse and format CLDR time patterns
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Maroš Kollár
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Format-CLDR-1.13-1.src.rpm
checksum_type: sha
description:
  This module provides a parser (and also a formater) for datetime strings
  using patterns as defined by the Unicode CLDR Project
  (Common Locale Data Repository). L<http://unicode.org/cldr/>.

  CLDR format is supported by L<DateTime> and L<DateTime::Locale> starting with
  version 0.40.


pkgId: 27ed9c22ae79d6c60aeb6a6beb53263ad0334e64
name: local-perl-DateTime-Format-Duration
arch: src
version: 1.03
epoch: 0
release: 1
summary: DateTime-Format-Duration - Format and parse DateTime::Durations
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Rick Measham <rickm@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Format-Duration-1.03-1.src.rpm
checksum_type: sha
description:
  use DateTime::Format::Duration;

  	$d = DateTime::Format::Duration->new(
  		pattern => '%Y years, %m months, %e days, '.
  				'%H hours, %M minutes, %SOURCE seconds'
  	);

  	print $d->format_duration(
  		DateTime::Duration->new(
  			years   => 3,
  			months  => 5,
  			days    => 1,
  			hours   => 6,
  			minutes => 15,
  			seconds => 45,
  			nanoseconds => 12000
  		)
  	);
  	


  	$duration = $d->parse_duration(
  		'3 years, 5 months, 1 days, 6 hours, 15 minutes, 45 seconds'
  	);
  	


  	print $d->format_duration_from_deltas(
  		years   => 3,
  		months  => 5,
  		days    => 1,
  		hours   => 6,
  		minutes => 15,
  		seconds => 45,
  		nanoseconds => 12000
  	);
  	

  	%deltas = $d->parse_duration_as_deltas(
    		'3 years, 5 months, 1 days, 6 hours, 15 minutes, 45 seconds'
  	);


pkgId: 7a475e07d7c7cf8d44d374c5a4d1d4f78975b2c3
name: local-perl-DateTime-Format-Flexible
arch: src
version: 0.20
epoch: 0
release: 1
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tom Heady (cpan@punch.net)
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Format-Flexible-0.20-1.src.rpm
checksum_type: sha
summary:
  DateTime-Format-Flexible - DateTime::Format::Flexible - Flexibly parse strings and turn them into DateTime objects.

description:
  If you have ever had to use a program that made you type in the date a certain
  way and thought "Why can't the computer just figure out what date I wanted?",
  this module is for you.

  F<DateTime::Format::Flexible> attempts to take any string you give it and parse
  it into a DateTime object.


pkgId: 2a2b2065a9ed2c062c696a2e2a7e96edc7c8b803
name: local-perl-DateTime-Format-IBeat
arch: src
version: 0.161
epoch: 0
release: 1
summary: DateTime-Format-IBeat - Format times in .beat notation
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: The late Iain <>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Format-IBeat-0.161-1.src.rpm
checksum_type: sha
description:
  No Time Zones

      No Geographical Borders

      How long is a Swatch .beat? In short, we have divided up the virtual and
      real day into 1000 I<beats>. One Swatch beat is the equivalent of 1
      minute 26.4 seconds. That means that 12 noon in the old time system is
      the equivalent of @500 Swatch .beats.

      Okay, so how can a surfer in New York, or a passenger on a transatlantic
      flight know when it is @500 Swatch .beats in Central Europe for example?
      How can the New York surfer make a date for a chat with his cyber friend
      in Rome? Easy, Internet Time is the same all over the world.

      How is this possible? We are not just creating a new way of measuring
      time, we are also creating a new meridian in Biel, Switzerland, home of
      Swatch.

      Biel MeanTime (BMT) is the universal reference for Internet Time. A day
      in Internet Time begins at midnight BMT (@000 Swatch .beats) (Central
      European Wintertime). The meridian is marked for all to see on the
      facade of the Swatch International Headquarters on Jakob-Staempfli
      Street, Biel, Switzerland. So, it is the same time all over the world,
      be it night or day, the era of time zones has disappeared.

      The BMT meridian was inaugurated on 23 October 1998 in the presence of
      Nicholas Negroponte, founder and director of the Massachusetts Institute
      of Technology`s Media Laboratory.

      - http://www.swatch.com/itime_tools/itime.php


pkgId: f6ef494ac137519e118d43e8a176dcae1d829229
name: local-perl-DateTime-Format-Oracle
arch: src
version: 0.05
epoch: 0
release: 1
summary: DateTime-Format-Oracle - Parse and format Oracle dates and timestamps
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Nathan Gray <kolibrie@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Format-Oracle-0.05-1.src.rpm
checksum_type: sha
description:
  This module may be used to convert Oracle date and timestamp values
  into C<DateTime> objects.  It also can take a C<DateTime> object and
  produce a date string matching the C<NLS_DATE_FORMAT>.

  Oracle has flexible date formatting via its C<NLS_DATE_FORMAT> session
  variable.  Date values will be returned from Oracle according to the
  current value of that variable.  Date values going into Oracle must also
  match the current setting of C<NLS_DATE_FORMAT>.

  Timestamp values will match either the C<NLS_TIMESTAMP_FORMAT> or
  C<NLS_TIMESTAMP_TZ_FORMAT> session variables.

  This module keeps track of these Oracle session variable values by
  examining environment variables of the same name.  Each time one of
  Oracle's formatting session variables is updated, the C<%ENV> hash
  must also be updated.


pkgId: 551ad22eca4431b58c2003ff40f10549733fc981
name: local-perl-DateTime-Format-Pg
arch: src
version: 0.16006
epoch: 0
release: 1
summary: DateTime-Format-Pg - Parse and format PostgreSQL dates and times
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Daisuke Maki <daisuke@endeworks.jp>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Format-Pg-0.16006-1.src.rpm
checksum_type: sha
description:
  This module understands the formats used by PostgreSQL for its DATE, TIME,
  TIMESTAMP, and INTERVAL data types.  It can be used to parse these formats in
  order to create C<DateTime> or C<DateTime::Duration> objects, and it can take a
  C<DateTime> or C<DateTime::Duration> object and produce a string representing
  it in a format accepted by PostgreSQL.


pkgId: 1f8b891a02ade7e8607c216fd98851a31e62c765
name: local-perl-DateTime-Format-Strptime
arch: src
version: 1.0702
epoch: 0
release: 3
summary: Parse and format strp and strf time patterns
url: http://search.cpan.org/dist/DateTime-Format-Strptime/
rpm_license: GPL+ or Artistic
rpm_group: Development/Libraries
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: local-perl-DateTime-Format-Strptime-1.0702-3.src.rpm
checksum_type: sha
description:
  This module implements most of strptime(3), the POSIX function that is the
  reverse of strftime(3), for DateTime. While strftime takes a DateTime and a
  pattern and returns a string, strptime takes a string and a pattern and
  returns the DateTime object associated.


pkgId: fef82d3162d9b9009e187a0b34fa854174e42fdc
name: local-perl-DateTime-Format-W3CDTF
arch: src
version: 0.04
epoch: 0
release: 1
summary: DateTime-Format-W3CDTF - Formatting and parsing of W3CDTF dates
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Kellan Elliott-McCrea <kellan@protest.net>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Format-W3CDTF-0.04-1.src.rpm
checksum_type: sha
description:
  This module understands the W3CDTF date/time format, an ISO 8601 profile,
  defined at http://www.w3.org/TR/NOTE-datetime.  This format as the native
  date format of RSS 1.0.

  It can be used to parse these formats in order to create the appropriate
  objects.


pkgId: 84a8276b63e7774be39adf2d812ed3bee6562921
name: local-perl-DateTime-Incomplete
arch: src
version: 0.06
epoch: 0
release: 1
summary: DateTime-Incomplete - Incomplete DateTime objects
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Flavio S. Glock <fglock@pucrs.br>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-DateTime-Incomplete-0.06-1.src.rpm
checksum_type: sha
description:
  DateTime::Incomplete is a class for representing partial dates and
  times.

  These are actually encountered relatively frequently.  For example, a
  birthday is commonly given as a month and day, without a year.


pkgId: 1ccd38549f24b3608b1794e0a7beea2448352b1b
name: local-perl-Devel-Cycle
arch: src
version: 1.10
epoch: 0
release: 1
summary: Devel-Cycle - Find memory cycles in objects
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Lincoln Stein <lstein@cshl.edu>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Devel-Cycle-1.10-1.src.rpm
checksum_type: sha
description:
  This is a simple developer's tool for finding circular references in
  objects and other types of references.  Because of Perl's
  reference-count based memory management, circular references will
  cause memory leaks.


pkgId: c34de672659e5ec9b0c92fb447e84695a36f6535
name: local-perl-Devel-GlobalDestruction
arch: src
version: 0.02
epoch: 0
release: 1
summary: Devel-GlobalDestruction - Expose PL_dirty, the flag which marks global
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Yuval Kogman <Eltnothingmuch@woobling.orgEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Devel-GlobalDestruction-0.02-1.src.rpm
checksum_type: sha
description:
  Perl's global destruction is a little tricky to deal with WRT finalizers
  because it's not ordered and objects can sometimes disappear.

  Writing defensive destructors is hard and annoying, and usually if global
  destruction is happenning you only need the destructors that free up non
  process local resources to actually execute.

  For these constructors you can avoid the mess by simply bailing out if global
  destruction is in effect.


pkgId: ec8b0d8bbe9b1eaa2bf34c0a9d0c19e519cb2f96
name: local-perl-Devel-NYTProf
arch: src
version: 2.03
epoch: 0
release: 1
summary: Devel-NYTProf - Powerful feature-rich perl source code profiler
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Adam Kaplan <akaplan@cpan.org>, Tim Bunce <timb@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Devel-NYTProf-2.03-1.src.rpm
checksum_type: sha
description:
  Devel::NYTProf is a powerful feature-rich perl source code profiler.

   * Performs per-line statement profiling for fine detail
   * Performs per-subroutine statement profiling for overview
   * Performs per-block statement profiling (the first profiler to do so)
   * Accounts correctly for time spent after calls return
   * Performs inclusive and exclusive timing of subroutines
   * Subroutine times are per calling location (a powerful feature)
   * Can profile compile-time activity, just run-time, or just END time
   * Uses novel techniques for efficient profiling
   * Sub-microsecond (100ns) resolution on systems with clock_gettime()
   * Very fast - the fastest statement and subroutine profilers for perl
   * Handles applications that fork, with no performance cost
   * Immune from noise caused by profiling overheads and I/O
   * Program being profiled can stop/start the profiler
   * Generates richly annotated and cross-linked html reports
   * Trivial to use with mod_perl - add one line to httpd.conf
   * Includes an extensive test suite
   * Tested on very large codebases

  NYTProf is effectively two profilers in one: a statement profiler, and a
  subroutine profiler.


pkgId: 979d498aa8dc6ac8e87cd6037b674c156878eced
name: local-perl-Devel-PPPort
arch: src
version: 3.19_02
epoch: 0
release: 1
summary: Devel-PPPort - Perl/Pollution/Portability
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Devel-PPPort-3.19_02-1.src.rpm
checksum_type: sha
description:
  Perl's API has changed over time, gaining new features, new functions,
  increasing its flexibility, and reducing the impact on the C namespace
  environment (reduced pollution). The header file written by this module,
  typically F<ppport.h>, attempts to bring some of the newer Perl API
  features to older versions of Perl, so that you can worry less about
  keeping track of old releases, but users can still reap the benefit.

  C<Devel::PPPort> contains a single function, called C<WriteFile>. Its
  only purpose is to write the F<ppport.h> C header file. This file
  contains a series of macros and, if explicitly requested, functions that
  allow XS modules to be built using older versions of Perl. Currently,
  Perl versions from __MIN_PERL__ to __MAX_PERL__ are supported.

  This module is used by C<h2xs> to write the file F<ppport.h>.


pkgId: a0deb6ea3e27aff56e19abe12bf38b30a9160fe4
name: local-perl-Devel-StackTrace-AsHTML
arch: src
version: 0.11
epoch: 0
release: 1
summary: Devel-StackTrace-AsHTML - Displays stack trace in HTML
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tatsuhiko Miyagawa <miyagawa@bulknews.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Devel-StackTrace-AsHTML-0.11-1.src.rpm
checksum_type: sha
description:
  Devel::StackTrace::AsHTML adds C<as_html> method to L<Devel::StackTrace> which
  displays the stack trace in beautiful HTML, with code snippet context and
  function parameters. If you call it on an instance of
  L<Devel::StackTrace::WithLexicals>, you even get to see the lexical variables
  of each stack frame.


pkgId: 00377fb6e268df937894ecb49c5419a451c30d87
name: local-perl-Devel-Symdump
arch: src
version: 2.08
epoch: 0
release: 1
summary: Devel-Symdump - dump symbol names or the symbol table
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andreas Koenig F <andk@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Devel-Symdump-2.08-1.src.rpm
checksum_type: sha
description:
  This little package serves to access the symbol table of perl.

  =over 4

  =item C<Devel::Symdump-E<gt>rnew(@packages)>

  returns a symbol table object for all subtrees below @packages.
  Nested Modules are analyzed recursively. If no package is given as
  argument, it defaults to C<main>. That means to get the whole symbol
  table, just do a C<rnew> without arguments.

  The global variable $Devel::Symdump::MAX_RECURSION limits the
  recursion to prevent contention. The default value is set to 97, just
  low enough to survive the test suite without a warning about deep
  recursion.

  =item C<Devel::Symdump-E<gt>new(@packages)>

  does not go into recursion and only analyzes the packages that are
  given as arguments.

  =item packages, scalars, arrays, hashes, functions, ios

  The methods packages(), scalars(), arrays(), hashes(), functions(),
  ios(), and (for older perls) unknowns() each return an array of fully
  qualified symbols of the specified type in all packages that are held
  within a Devel::Symdump object, but without the leading C<$>, C<@> or
  C<%>. In a scalar context, they will return the number of such
  symbols. Unknown symbols are usually either formats or variables that
  haven't yet got a defined value.

  =item as_string

  =item as_HTML

  As_string() and as_HTML() return a simple string/HTML representations
  of the object.

  =item diff

  Diff() prints the difference between two Devel::Symdump objects in
  human readable form. The format is similar to the one used by the
  as_string method.

  =item isa_tree

  =item inh_tree

  Isa_tree() and inh_tree() both return a simple string representation
  of the current inheritance tree. The difference between the two
  methods is the direction from which the tree is viewed: top-down or
  bottom-up. As I'm sure, many users will have different expectation
  about what is top and what is bottom, I'll provide an example what
  happens when the Socket module is loaded:

  =item % print Devel::Symdump-E<gt>inh_tree

      AutoLoader
              DynaLoader
                      Socket
      DynaLoader
              Socket
      Exporter
              Carp
              Config
              Socket

  The inh_tree method shows on the left hand side a package name and
  indented to the right the packages that use the former.

  =item % print Devel::Symdump-E<gt>isa_tree

      Carp
              Exporter
      Config
              Exporter
      DynaLoader
              AutoLoader
      Socket
              Exporter
              DynaLoader
                      AutoLoader

  The isa_tree method displays from left to right ISA relationships, so
  Socket IS A DynaLoader and DynaLoader IS A AutoLoader. (Actually, they
  were at the time this manpage was written)

  =back

  You may call both methods, isa_tree() and inh_tree(), with an
  object. If you do that, the object will store the output and retrieve
  it when you call the same method again later. The typical usage would
  be to use them as class methods directly though.


pkgId: ffb0d2f00fb3692cb2e562bba6beec6359fce690
name: local-perl-Digest
arch: src
version: 1.17
epoch: 0
release: 1
summary: Digest - Modules that calculate message digests
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Gisle Aas <gisle@activestate.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-1.17-1.src.rpm
checksum_type: sha
description:
  The C<Digest::> modules calculate digests, also called "fingerprints"
  or "hashes", of some data, called a message.  The digest is (usually)
  some small/fixed size string.  The actual size of the digest depend of
  the algorithm used.  The message is simply a sequence of arbitrary
  bytes or bits.

  An important property of the digest algorithms is that the digest is
  I<likely> to change if the message change in some way.  Another
  property is that digest functions are one-way functions, that is it
  should be I<hard> to find a message that correspond to some given
  digest.  Algorithms differ in how "likely" and how "hard", as well as
  how efficient they are to compute.

  Note that the properties of the algorithms change over time, as the
  algorithms are analyzed and machines grow faster.  If your application
  for instance depends on it being "impossible" to generate the same
  digest for a different message it is wise to make it easy to plug in
  stronger algorithms as the one used grow weaker.  Using the interface
  documented here should make it easy to change algorithms later.

  All C<Digest::> modules provide the same programming interface.  A
  functional interface for simple use, as well as an object oriented
  interface that can handle messages of arbitrary length and which can
  read files directly.

  The digest can be delivered in three formats:

  =over 8

  =item I<binary>

  This is the most compact form, but it is not well suited for printing
  or embedding in places that can't handle arbitrary data.

  =item I<hex>

  A twice as long string of lowercase hexadecimal digits.

  =item I<base64>

  A string of portable printable characters.  This is the base64 encoded
  representation of the digest with any trailing padding removed.  The
  string will be about 30% longer than the binary version.
  L<MIME::Base64> tells you more about this encoding.

  =back


  The functional interface is simply importable functions with the same
  name as the algorithm.  The functions take the message as argument and
  return the digest.  Example:

    use Digest::MD5 qw(md5);
    $digest = md5($message);

  There are also versions of the functions with "_hex" or "_base64"
  appended to the name, which returns the digest in the indicated form.


pkgId: 6c8ccba55f2ed299b8cce38edebdfad437706e50
name: local-perl-Digest-BubbleBabble
arch: src
version: 0.01
epoch: 0
release: 1
summary: Digest-BubbleBabble - Create bubble-babble fingerprints
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Benjamin Trott <ben@rhumba.pair.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-BubbleBabble-0.01-1.src.rpm
checksum_type: sha
description:
  I<Digest::BubbleBabble> takes a message digest (generated by
  either of the MD5 or SHA-1 message digest algorithms) and creates
  a fingerprint of that digest in "bubble babble" format.
  Bubble babble is a method of representing a message digest
  as a string of "real" words, to make the fingerprint easier
  to remember. The "words" are not necessarily real words, but
  they look more like words than a string of hex characters.

  Bubble babble fingerprinting is used by the SSH2 suite
  (and, consequently, by I<Net::SSH::Perl>, the Perl SSH
  implementation) to display easy-to-remember key fingerprints.
  The key (a DSA or RSA key) is converted into a textual form,
  digested using I<Digest::SHA1>, and run through I<bubblebabble>
  to create the key fingerprint.


pkgId: 984e68ff9f1ab3aa97d9e5b9aa89546ca6f81199
name: local-perl-Digest-HMAC
arch: src
version: 1.01
epoch: 0
release: 1
summary: Digest-HMAC - Keyed-Hashing for Message Authentication
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Graham Barr <gbarr@ti.com,>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-HMAC-1.01-1.src.rpm
checksum_type: sha
description:
  HMAC is used for message integrity checks between two parties that
  share a secret key, and works in combination with some other Digest
  algorithm, usually MD5 or SHA-1.  The HMAC mechanism is described in
  RFC 2104.

  HMAC follow the common C<Digest::> interface, but the constructor
  takes the secret key and the name of some other simple C<Digest::>
  as argument.


pkgId: 0bfa9d92f00809a1c58edcb1426a9fc43e3d3345
name: local-perl-Digest-JHash
arch: src
version: 0.05
epoch: 0
release: 1
summary: Digest-JHash - Perl extension for 32 bit Jenkins Hashing Algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Dr James Freeman
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-JHash-0.05-1.src.rpm
checksum_type: sha
description:
  The C<Digest::JHash> module allows you to use the fast JHash hashing algorithm
  developed by Bob Jenkins from within Perl programs. The algorithm takes as
  input a message of arbitrary length and produces as output a 32-bit
  "message digest" of the input in the form of an unsigned long integer.

  Call it a low calorie version of MD5 if you like.

  See http://burtleburtle.net/bob/hash/doobs.html for more information.


pkgId: af1f33187cdb8a2f789c3e40131bd84b5d657fb6
name: local-perl-Digest-MD2
arch: src
version: 2.03
epoch: 0
release: 1
summary: Digest-MD2 - Perl interface to the MD2 Algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Gisle Aas <gisle@aas.no>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-MD2-2.03-1.src.rpm
checksum_type: sha
description:
  The C<Digest::MD2> module allows you to use the RSA Data Security
  Inc. MD2 Message Digest algorithm from within Perl programs.  The
  algorithm takes as input a message of arbitrary length and produces as
  output a 128-bit "fingerprint" or "message digest" of the input.

  The C<Digest::MD2> programming interface is identical to the interface
  of C<Digest::MD5>.


pkgId: b207a49cead7aa36d9fbc6d12e510bb261b9da93
name: local-perl-Digest-MD4
arch: src
version: 1.5
epoch: 0
release: 1
summary: Digest-MD4 - Perl interface to the MD4 Algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Neil Winton <CN.Winton@axion.bt.co.uk>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-MD4-1.5-1.src.rpm
checksum_type: sha
description:
  The C<Digest::MD4> module allows you to use the RSA Data Security
  Inc. MD4 Message Digest algorithm from within Perl programs.  The
  algorithm takes as input a message of arbitrary length and produces as
  output a 128-bit "fingerprint" or "message digest" of the input.

  The C<Digest::MD4> module provide a procedural interface for simple
  use, as well as an object oriented interface that can handle messages
  of arbitrary length and which can read files directly.


pkgId: 2eee142597a6faef9c1847b0f94f4cad38cc2b03
name: local-perl-Digest-MD5
arch: src
version: 2.36
epoch: 0
release: 1
summary: Digest-MD5 - Perl interface to the MD5 Algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Neil Winton <CN.Winton@axion.bt.co.uk>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-MD5-2.36-1.src.rpm
checksum_type: sha
description:
  The C<Digest::MD5> module allows you to use the RSA Data Security
  Inc. MD5 Message Digest algorithm from within Perl programs.  The
  algorithm takes as input a message of arbitrary length and produces as
  output a 128-bit "fingerprint" or "message digest" of the input.

  Note that the MD5 algorithm is not as strong as it used to be.  It has
  since 2005 been easy to generate different messages that produce the
  same MD5 digest.  It still seems hard to generate messages that
  produce a given digest, but it is probably wise to move to stronger
  algorithms for applications that depend on the digest to uniquely identify
  a message.

  The C<Digest::MD5> module provide a procedural interface for simple
  use, as well as an object oriented interface that can handle messages
  of arbitrary length and which can read files directly.


pkgId: 32cbe837f95009b0d6fa2b249e5e9ac61a8cba8f
name: local-perl-Digest-Perl-MD4
arch: src
version: 1.4
epoch: 0
release: 1
summary: Digest-Perl-MD4 - Perl implementation of Ron Rivests MD4 Algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: by Neil Winton <N.Winton@axion.bt.co.uk>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-Perl-MD4-1.4-1.src.rpm
checksum_type: sha
description:
  This modules has the same interface as C<Digest::MD5>.  It should be compatible
   with the Digest::MD4 module written by Mike McCauley <mikem@open.com.au>.


pkgId: 87e712ea061c2c8c6a190d2bbcbc1d697ffc4588
name: local-perl-Digest-Perl-MD5
arch: src
version: 1.8
epoch: 0
release: 1
summary: Digest-Perl-MD5 - Perl Implementation of Rivest's MD5 algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Christian Lackas <delta@clackas.de>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-Perl-MD5-1.8-1.src.rpm
checksum_type: sha
description:
  This modules has the same interface as the much faster C<Digest::MD5>. So you can
  easily exchange them, e.g.

  	BEGIN {
  	  eval {
  	    require Digest::MD5;
  	    import Digest::MD5 'md5_hex'
  	  };
  	  if ($@) { # ups, no Digest::MD5
  	    require Digest::Perl::MD5;
  	    import Digest::Perl::MD5 'md5_hex'
  	  }
  	}

  If the C<Digest::MD5> module is available it is used and if not you take
  C<Digest::Perl::MD5>.

  You can also install the Perl part of Digest::MD5 together with Digest::Perl::MD5
  and use Digest::MD5 as normal, it falls back to Digest::Perl::MD5 if it
  cannot load its object files.

  For a detailed Documentation see the C<Digest::MD5> module.


pkgId: 87b0646b8dff6352a16c15f026e26fb1e3043aa4
name: local-perl-Digest-SHA1
arch: src
version: 2.11
epoch: 0
release: 1
summary: Digest-SHA1 - Perl interface to the SHA-1 algorithm
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: GutmannUwe Hollerbach <uh@alumni.caltech.edu,>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Digest-SHA1-2.11-1.src.rpm
checksum_type: sha
description:
  The C<Digest::SHA1> module allows you to use the NIST SHA-1 message
  digest algorithm from within Perl programs.  The algorithm takes as
  input a message of arbitrary length and produces as output a 160-bit
  "fingerprint" or "message digest" of the input.

  The C<Digest::SHA1> module provide a procedural interface for simple
  use, as well as an object oriented interface that can handle messages
  of arbitrary length and which can read files directly.


pkgId: babbe5ecd33717f62d59e31aa7c503c11719326c
name: local-perl-EV
arch: src
version: 3.9
epoch: 0
release: 1
summary: EV - perl interface to libev, a high performance full-featured event loop
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Marc Lehmann <schmorp@schmorp.de>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-EV-3.9-1.src.rpm
checksum_type: sha
description:
  This module provides an interface to libev
  (L<http://software.schmorp.de/pkg/libev.html>). While the documentation
  below is comprehensive, one might also consult the documentation of
  libev itself (L<http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod> or
  F<perldoc EV::libev>) for more subtle details on watcher semantics or some
  discussion on the available backends, or how to force a specific backend
  with C<LIBEV_FLAGS>, or just about in any case because it has much more
  detailed information.

  This module is very fast and scalable. It is actually so fast that you
  can use it through the L<AnyEvent> module, stay portable to other event
  loops (if you don't rely on any watcher types not available through it)
  and still be faster than with any other event loop currently supported in
  Perl.


pkgId: 37d94f05436e795e145a10e21e3e77bb6fee602a
name: local-perl-Email-Abstract
arch: src
version: 2.134
epoch: 0
release: 1
summary: Email-Abstract - unified interface to mail representations
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Casey West <Fcasey@geeknest.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-Abstract-2.134-1.src.rpm
checksum_type: sha
description:
  C<Email::Abstract> provides module writers with the ability to write
  simple, representation-independent mail handling code. For instance, in the
  cases of C<Mail::Thread> or C<Mail::ListDetector>, a key part of the code
  involves reading the headers from a mail object. Where previously one would
  either have to specify the mail class required, or to build a new object from
  scratch, C<Email::Abstract> can be used to perform certain simple operations on
  an object regardless of its underlying representation.

  C<Email::Abstract> currently supports C<Mail::Internet>, C<MIME::Entity>,
  C<Mail::Message>, C<Email::Simple> and C<Email::MIME>.  Other representations
  are encouraged to create their own C<Email::Abstract::*> class by copying
  C<Email::Abstract::EmailSimple>.  All modules installed under the
  C<Email::Abstract> hierarchy will be automatically picked up and used.


pkgId: 6b33ce54420af743e867473d8701c5c2efa411e1
name: local-perl-Email-Address
arch: src
version: 1.889
epoch: 0
release: 1
summary: Email-Address - RFC 2822 Address Parsing
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Casey West <casey@geeknest.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-Address-1.889-1.src.rpm
checksum_type: sha
description:
  This class implements a regex-based RFC 2822 parser that locates email
  addresses in strings and returns a list of C<Email::Address> objects found.
  Alternatley you may construct objects manually. The goal of this software is to
  be correct, and very very fast.


pkgId: c4b20126695ea636feec338643b6f0e93c76ba34
name: local-perl-Email-ConstantContact
arch: src
version: 0.05
epoch: 0
release: 1
summary: Email-ConstantContact - Perl interface to the ConstantContact API
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Adam Rich <arich@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-ConstantContact-0.05-1.src.rpm
checksum_type: sha
description:
  This module allows you to interact with the ConstantContact mass email
  marketing service from perl, such as creating and mainting contacts and
  contact lists.

  Before using this module, you must register your application with the
  ConstantContact company, agree to their terms & conditions, and apply
  for an API access key.  You will use this key, in combination with a
  ConstantContact username and password to interact with the service.

      use Email::ConstantContact;

      my $apikey = 'ABCDEFG1234567';
      my $username = 'mycompany';
      my $password = 'topsecret';

      my $cc = new Email::ConstantContact($apikey, $username, $password);

      
      my @all_lists = $cc->lists();
      foreach my $list (@all_lists) {
          print "Found list: ", $list->{Name}, "\n";
      }

      
      my $new_list = $cc->newList('JAPH Newsletter', {
          SortOrder		=> '70',
          DisplayOnSignup		=> 'false',
          OptInDefault		=> 'false',
      });

      
      my $new_contact = $cc->newContact('jdoe@example.com', {
          FirstName	=> 'John',
          LastName	=> 'Doe',
          CompanyName	=> 'JD Industries',
          ContactLists	=> [ $new_list ],
      });

      
      my $old_contact = $cc->getContact('yogi@example.com');
      print "Yogi no longer works for ", $old_contact->{CompanyName}, "\n";
      $old_contact->{CompanyName} = 'Acme Corp';

      
      print "Member of Lists: \n";
      foreach my $listid (@{ $old_contact->{ContactLists} }) {
          my $listobj = $cc->getList($listid);
          print $listobj->{Name}, "\n";
      }

      
      $old_contact->removeFromList($some_list_id);
      $old_contact->clearAllLists();
      $old_contact->addToList($new_list);
      $old_contact->save();

      
      $old_contact->optOut();
      $old_contact->save();

      
      my @recent_activities = $cc->activities();

      foreach my $activity (@recent_activities) {
          print "Found recent activity, Type= ", $activity->{Type},
              "Status= ", $activity->{Status}, "\n";
      }

  	
  	foreach my $camp ($cc->campaigns('SENT')) {
  		foreach my $event ($camp->events('bounces')) {
  			if ($event->{Code} eq 'B') {
  				print "Bounced: ", $event->{Contact}->{EmailAddress}, "\n";
  			}
  		}
  	}


pkgId: 9138b1ef64f1e97a7a8561559107f2a638afa99b
name: local-perl-Email-Date
arch: src
version: 1.103
epoch: 0
release: 1
summary: Email-Date - Find and Format Date Headers
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Casey West <casey@geeknest.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-Date-1.103-1.src.rpm
checksum_type: sha
description:
  RFC 2822 defines the C<Date:> header. It declares the header a required
  part of an email message. The syntax for date headers is clearly laid
  out. Stil, even a perfectly planned world has storms. The truth is, many
  programs get it wrong. Very wrong. Or, they don't include a C<Date:> header
  at all. This often forces you to look elsewhere for the date, and hoping
  to find something.

  For this reason, the tedious process of looking for a valid date has been
  encapsulated in this software. Further, the process of creating RFC
  compliant date strings is also found in this software.


pkgId: d7c7d55143fdbd0367dfd87da554f5bbfc5a197c
name: local-perl-Email-Date-Format
arch: src
version: 1.002
epoch: 0
release: 1
summary: Email-Date-Format - produce RFC 8822 date strings
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ricardo SIGNES <rjbs@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-Date-Format-1.002-1.src.rpm
checksum_type: sha
description:
  This module provides a simple means for generating an RFC 2822 compliant
  datetime string.  (In case you care, they're not RFC 822 dates, because they
  use a four digit year, which is not allowed in RFC 822.)


pkgId: 57d10e26cd88301f3253d2c4ffe3031a087d69a3
name: local-perl-Email-Find
arch: src
version: 0.10
epoch: 0
release: 1
summary: Email-Find - Find RFC 822 email addresses in plain text
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michael G Schwern <Eltschwern@pobox.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-Find-0.10-1.src.rpm
checksum_type: sha
description:
  Email::Find is a module for finding a I<subset> of RFC 822 email
  addresses in arbitrary text (see L</"CAVEATS">).  The addresses it
  finds are not guaranteed to exist or even actually be email addresses
  at all (see L</"CAVEATS">), but they will be valid RFC 822 syntax.

  Email::Find will perform some heuristics to avoid some of the more
  obvious red herrings and false addresses, but there's only so much
  which can be done without a human.


pkgId: e5e54e9d53568874645bbf873874a8086dc1fc8c
name: local-perl-Email-Simple
arch: src
version: 2.004
epoch: 0
release: 1
summary: Email-Simple - simple parsing of RFC2822 message format and headers
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Simon Cozens originally <>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-Simple-2.004-1.src.rpm
checksum_type: sha
description:
  C<Email::Simple> is the first deliverable of the "Perl Email Project."  The
  Email:: namespace was begun as a reaction against the increasing complexity and
  bugginess of Perl's existing email modules.  C<Email::*> modules are meant to
  be simple to use and to maintain, pared to the bone, fast, minimal in their
  external dependencies, and correct.


pkgId: 0b60165536eea0ae6f021db3e8ad595ca4e1b2ac
name: local-perl-Email-Simple-Headers
arch: src
version: 1.02
epoch: 0
release: 1
summary: Email-Simple-Headers - List Headers From Simple Objects
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Casey West <casey@geeknest.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-Simple-Headers-1.02-1.src.rpm
checksum_type: sha
description:
  This software provides an instance method for
  L<Email::Simple|Email::Simple> to get a list of headers.


pkgId: d16b876aee9f6b6b6dd651d5a78513e0c6c344cb
name: local-perl-Email-Valid
arch: src
version: 0.179
epoch: 0
release: 1
summary: Email-Valid - Check validity of Internet email addresses
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Maurice Aubrey <Eltmaurice@hevanet.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Email-Valid-0.179-1.src.rpm
checksum_type: sha
description:
  This module determines whether an email address is well-formed, and
  optionally, whether a mail host exists for the domain.

  Please note that there is no way to determine whether an
  address is deliverable without attempting delivery (for details, see
  perlfaq 9).


pkgId: dc68b06fb15b8b90bb65ee4ae6e6f28696fb11dd
name: local-perl-Encode-Detect
arch: src
version: 1.01
epoch: 0
release: 1
summary: Encode-Detect - An Encode::Encoding subclass that detects the encoding of data
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: John Gardiner Myers <jgmyers@proofpoint.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Encode-Detect-1.01-1.src.rpm
checksum_type: sha
description:
  This Perl module is an Encode::Encoding subclass that uses
  Encode::Detect::Detector to determine the charset of the input data
  and then decodes it using the encoder of the detected charset.

  It is similar to Encode::Guess, but does not require the configuration
  of a set of expected encodings.  Like Encode::Guess, it only supports
  decoding--it cannot encode.


pkgId: 586fa0af5da0cba72f1bf438c0e2255dc3c717e2
name: local-perl-Event-Lib
arch: src
version: 1.03
epoch: 0
release: 1
summary: Event-Lib - Perl extentions for event-based programming
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tassilo von Parseval <tassilo.von.parseval@rwth-aachen.de>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Event-Lib-1.03-1.src.rpm
checksum_type: sha
description:
  This module is a Perl wrapper around libevent(3) as available from
  L<http://www.monkey.org/~provos/libevent/>.  It allows to execute a function
  whenever a given event on a filehandle happens, a timeout occurs or a signal is
  received.

  Under the hood, one of the available mechanisms for asynchronously dealing with
  events is used. This could be C<select>, C<poll>, C<epoll>, C<devpoll> or
  C<kqueue>. The idea is that you don't have to worry about those details and the
  various interfaces they offer. I<Event::Lib> offers a unified interface  to all
  of them (but see L<"CONFIGURATION"> further below).

  Once you've skimmed through the next two sections (or maybe even now), you
  should have a look at L<"EXAMPLE: A SIMPLE TCP SERVER"> to get a feeling about
  how it all fits together.

  There's also a section briefly mentioning other event modules on the CPAN
  and how they differ from I<Event::Lib> further below (L<"OTHER EVENT MODULES">).


pkgId: 2fe3f31f44c509fb5d462aaa831b33f0bba55887
name: local-perl-Expect-Simple
arch: src
version: 0.04
epoch: 0
release: 1
summary: Expect-Simple - wrapper around the Expect module
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Diab Jerius <djerius@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Expect-Simple-0.04-1.src.rpm
checksum_type: sha
description:
  C<Expect::Simple> is a wrapper around the C<Expect> module which
  should suffice for simple applications.  It hides most of the
  C<Expect> machinery; the C<Expect> object is available for tweaking if
  need be.

  Generally, one starts by creating an B<Expect::Simple> object using
  B<new>.  This will start up the target program, and will wait until
  one of the specified prompts is output by the target.  At that point
  the caller should B<send()> commands to the program; the results are
  available via the B<before>, B<after>, B<match_str>, and B<match_idx>
  methods.  Since B<Expect> simulates a terminal, there will be extra
  C<\r> characters at the end of each line in the result (on UNIX at
  least).  This is easily fixed:

      ($res = $obj->before) =~ tr/\r//d;
      @lines = split( "\n", $res );

  This is B<not> done automatically.


  Exceptions will be thrown on error (match with C</Expect::Simple/>).
  Errors from B<Expect> are available via the B<error_expect> method.
  More human readable errors are available via the B<error> method.

  The connection is automatically broken (by sending the specified
  disconnect command to the target) when the B<Expect::Simple> object is
  destroyed.


pkgId: f85d809a6859aef015266b4a4cf187e5718edc47
name: local-perl-Exporter-Lite
arch: src
version: 0.02
epoch: 0
release: 1
summary: Exporter-Lite - Lightweight exporting of variables
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michael G Schwern <schwern@pobox.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Exporter-Lite-0.02-1.src.rpm
checksum_type: sha
description:
  This is an alternative to Exporter intended to provide a lightweight
  subset of its functionality.  It supports C<import()>, C<@EXPORT> and
  C<@EXPORT_OK> and not a whole lot else.

  Unlike Exporter, it is not necessary to inherit from Exporter::Lite
  (ie. no C<@ISA = qw(Exporter::Lite)> mantra).  Exporter::Lite simply
  exports its import() function.  This might be called a "mix-in".

  Setting up a module to export its variables and functions is simple:

      package My::Module;
      use Exporter::Lite;

      @EXPORT = qw($Foo bar);

  now when you C<use My::Module>, C<$Foo> and C<bar()> will show up.

  In order to make exporting optional, use @EXPORT_OK.

      package My::Module;
      use Exporter::Lite;

      @EXPORT_OK = qw($Foo bar);

  when My::Module is used, C<$Foo> and C<bar()> will I<not> show up.
  You have to ask for them.  C<use My::Module qw($Foo bar)>.


pkgId: cd82f7f271a3c43c6b7a5f183768a6ae77f68420
name: local-perl-ExtUtils-Depends
arch: src
version: 0.302
epoch: 0
release: 1
summary: ExtUtils-Depends - Easily build XS extensions that depend on XS extensions
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Paolo Molaro <lupus@debian>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-ExtUtils-Depends-0.302-1.src.rpm
checksum_type: sha
description:
  This module tries to make it easy to build Perl extensions that use
  functions and typemaps provided by other perl extensions. This means
  that a perl extension is treated like a shared library that provides
  also a C and an XS interface besides the perl one.

  This works as long as the base extension is loaded with the RTLD_GLOBAL
  flag (usually done with a

  	sub dl_load_flags {0x01}

  in the main .pm file) if you need to use functions defined in the module.

  The basic scheme of operation is to collect information about a module
  in the instance, and then store that data in the Perl library where it
  may be retrieved later.  The object can also reformat this information
  into the data structures required by ExtUtils::MakeMaker's WriteMakefile
  function.

  When creating a new Depends object, you give it a name, which is the name
  of the module you are building.   You can also specify the names of modules
  on which this module depends.  These dependencies will be loaded
  automatically, and their typemaps, header files, etc merged with your new
  object's stuff.  When you store the data for your object, the list of
  dependencies are stored with it, so that another module depending on your
  needn't know on exactly which modules yours depends.

  For example:

    Gtk2 depends on Glib

    Gnome2::Canvas depends on Gtk2

    ExtUtils::Depends->new ('Gnome2::Canvas', 'Gtk2');
       this command automatically brings in all the stuff needed
       for Glib, since Gtk2 depends on it.


pkgId: 28a0f456fdc5195292aa34681a0d4c1de5831ed7
name: local-perl-ExtUtils-MakeMaker
arch: src
version: 6.71_01
epoch: 0
release: 1
summary: ExtUtils-MakeMaker - Create a module Makefile
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michael G Schwern <schwern@pobox.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-ExtUtils-MakeMaker-6.71_01-1.src.rpm
checksum_type: sha
description:
  This utility is designed to write a Makefile for an extension module
  from a Makefile.PL. It is based on the Makefile.SH model provided by
  Andy Dougherty and the perl5-porters.

  It splits the task of generating the Makefile into several subroutines
  that can be individually overridden.  Each subroutine returns the text
  it wishes to have written to the Makefile.

  As there are various Make programs with incompatible syntax, which
  use operating system shells, again with incompatible syntax, it is
  important for users of this module to know which flavour of Make
  a Makefile has been written for so they'll use the correct one and
  won't have to face the possibly bewildering errors resulting from
  using the wrong one.

  On POSIX systems, that program will likely be GNU Make; on Microsoft
  Windows, it will be either Microsoft NMake or DMake. Note that this
  module does not support generating Makefiles for GNU Make on Windows.
  See the section on the L</"MAKE"> parameter for details.

  MakeMaker is object oriented. Each directory below the current
  directory that contains a Makefile.PL is treated as a separate
  object. This makes it possible to write an unlimited number of
  Makefiles with a single invocation of WriteMakefile().


pkgId: 93405df48e120cfa67d6640381ddeea47777c078
name: local-perl-ExtUtils-ParseXS
arch: src
version: 2.2205
epoch: 1
release: 1
summary: ExtUtils-ParseXS - converts Perl XS code into C code
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Based on xsubpp <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-ExtUtils-ParseXS-2.2205-1.src.rpm
checksum_type: sha
description:
  C<ExtUtils::ParseXS> will compile XS code into C code by embedding the constructs
  necessary to let C functions manipulate Perl values and creates the glue
  necessary to let Perl access those functions.  The compiler uses typemaps to
  determine how to map C function parameters and variables to Perl values.

  The compiler will search for typemap files called I<typemap>.  It will use
  the following search path to find default typemaps, with the rightmost
  typemap taking precedence.

  	../../../typemap:../../typemap:../typemap:typemap


pkgId: 0d9386d6fcd99518559a0b94e2ca72b10b96f054
name: local-perl-ExtUtils-PkgConfig
arch: src
version: 1.12
epoch: 0
release: 1
summary: ExtUtils-PkgConfig - simplistic interface to pkg-config
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: muppet <Eltscott@asofyet>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-ExtUtils-PkgConfig-1.12-1.src.rpm
checksum_type: sha
description:
  The pkg-config program retrieves information about installed libraries,
  usually for the purposes of compiling against and linking to them.

  ExtUtils::PkgConfig is a very simplistic interface to this utility, intended
  for use in the Makefile.PL of perl extensions which bind libraries that
  pkg-config knows.  It is really just boilerplate code that you would've
  written yourself.


pkgId: 7d1a4032546b403449ba5c4bea5e7558ff09f7ab
name: local-perl-FNet-Config
arch: src
version: 1.0
epoch: 0
release: 2.ep
summary: FNet::Config - cross-environment glue module
url: http://www.endpoint.com/
rpm_license: Artistic
rpm_vendor: End Point Corporation
rpm_group: Applications/Web
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Jon Jensen <jon@endpoint.com>
location_href: local-perl-FNet-Config-1.0-2.ep.src.rpm
checksum_type: sha
description:
  FNet::Config is the glue for Perl code to detect its place in
  camp, qa, staging, or production environments.


pkgId: a8ee7b15d24afab65a87dd77a1f56ff2cc972748
name: local-perl-File-Copy-Recursive
arch: src
version: 0.36
epoch: 0
release: 1
summary: File-Copy-Recursive - Perl extension for recursively copying files and directories
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Daniel Muey <http://drmuey.com/cpan_contact.pl>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Copy-Recursive-0.36-1.src.rpm
checksum_type: sha
description:
  This module copies and moves directories recursively (or single files, well... singley) to an optional depth and attempts to preserve each file or directory's mode.


pkgId: dc59c4491e62cdfc897bc04e4ad02430e098e700
name: local-perl-File-Find-Rule
arch: src
version: 0.33
epoch: 0
release: 1
summary: File-Find-Rule - Alternative interface to File::Find
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Richard Clamp <richardc@unixbeard.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Find-Rule-0.33-1.src.rpm
checksum_type: sha
description:
  File::Find::Rule is a friendlier interface to File::Find.  It allows
  you to build rules which specify the desired files and directories.


pkgId: e26084259eb23e25386c736e09403bb3e734151e
name: local-perl-File-FnMatch
arch: src
version: 0.02
epoch: 0
release: 1
summary: File-FnMatch - simple filename and pathname matching
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michael J. Pomraning <mjp-perl@pilcrow.madison.wi.us>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-FnMatch-0.02-1.src.rpm
checksum_type: sha
description:
  File::FnMatch::fnmatch() provides simple, shell-like pattern matching.

  Though considerably less powerful than regular expressions, shell patterns
  are nonetheless useful and familiar to a large audience of end-users.


pkgId: ba4a135979f97492e9de80cb4b52c2c754075b08
name: local-perl-File-Modified
arch: src
version: 0.07
epoch: 0
release: 1
summary: File-Modified - checks intelligently if files have changed
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Max Maischein <corion@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Modified-0.07-1.src.rpm
checksum_type: sha
description:
  The Modified module is intended as a simple method for programs to detect
  whether configuration files (or modules they rely on) have changed. There are
  currently two methods of change detection implemented, C<mtime> and C<MD5>.
  The C<MD5> method will fall back to use timestamps if the C<Digest::MD5> module
  cannot be loaded.

  There is another module, L<File::Signature>, which has many similar features,
  so if this module doesn't do what you need, maybe File::Signature does. There
  also is quite some overlap between the two modules, code wise.

  =over 4

  =item new %ARGS

  Creates a new instance. The C<%ARGS> hash has two possible keys,
  C<Method>, which denotes the method used for checking as default,
  and C<Files>, which takes an array reference to the filenames to
  watch.

  =item add filename, method

  Adds a new file to watch. C<method> is the method (or rather, the
  subclass of C<File::Modified::Signature>) to use to determine whether
  a file has changed or not. The result is either the C<File::Modified::Signature>
  subclass or undef if an error occurred.

  =item addfile LIST

  Adds a list of files to watch. The method used for watching is the
  default method as set in the constructor. The result is a list
  of C<File::Modified::Signature> subclasses.

  =item update

  Updates all signatures to the current state. All pending changes
  are discarded.

  =item changed

  Returns a list of the filenames whose files did change since
  the construction or the last call to C<update> (whichever last
  occurred).

  =back


pkgId: b3f96885b9a6085af197b69c657e8d8dffb65f78
name: local-perl-File-NFSLock
arch: src
version: 1.20
epoch: 0
release: 1
summary: File-NFSLock - perl module to do NFS (or not) locking
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Paul Seamons
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-NFSLock-1.20-1.src.rpm
checksum_type: sha
description:
  Program based of concept of hard linking of files being atomic across
  NFS.  This concept was mentioned in Mail::Box::Locker (which was
  originally presented in Mail::Folder::Maildir).  Some routine flow is
  taken from there -- particularly the idea of creating a random local
  file, hard linking a common file to the local file, and then checking
  the nlink status.  Some ideologies were not complete (uncache
  mechanism, shared locking) and some coding was even incorrect (wrong
  stat index).  File::NFSLock was written to be light, generic,
  and fast.


pkgId: 2d24e90351369cea715be8b00668b4ec64831294
name: local-perl-File-Next
arch: src
version: 1.02
epoch: 0
release: 1
summary: File-Next - File-finding iterator
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andy Lester <andy@petdance.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Next-1.02-1.src.rpm
checksum_type: sha
description:
  File::Next is a lightweight, taint-safe file-finding module.
  It's lightweight and has no non-core prerequisites.

      use File::Next;

      my $files = File::Next::files( '/tmp' );

      while ( defined ( my $file = $files->() ) ) {
          
      }


pkgId: 4eec031e864271734fae9cf82f5002e48009f635
name: local-perl-File-Path-Tiny
arch: src
version: 0.3
epoch: 0
release: 1
summary: File-Path-Tiny - recursive versions of mkdir() and rmdir() without as much overhead as File::Path
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Daniel Muey <http://drmuey.com/cpan_contact.pl>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Path-Tiny-0.3-1.src.rpm
checksum_type: sha
description:
  The goal here is simply to provide recursive versions of L<mkdir>() and L<rmdir>() with as little code and overhead as possible.

  This module is in no way meant to derogate L<File::Path> and is in no way an endorsement to go out and replace all use of L<File::Path> with L<File::Path::Tiny>.

  L<File::Path> is very good at what it does but there's simply a lot happening that we can do without much of the time.

  Here are some things L<File::Path> has/does that this module attempts to do without:

  =over 4

  =item * multiple interfaces

  Backwards compatibility brings in a lot of code and logic that we don't need from here on out.

  =item * chdir's

  It does a ton of chdir's which could leave you somewhere you're not planning on being and requires much more overhead to do.

  =item * can croak not allowing you to detect and handle failure

  Just let me handle errors how I want. Don't make my entire app die or have to wrap it in an eval

  =item * A well intentioned output system

  Just let me do the output how I want. (Nothing, As HTML, print to a filehandle, etc...)

  =item * A well intentioned and experimental (IE subject to change) error handling system.

  Just keep it simple and detect failure via a boolean check and do what I want with the error. See L</"How can I make/remove multiple paths?">

  =item * According to its POD, removing a tree is apparently not safe unless you tell it to be with the 'safe' or 'keep_root' attributes.

  Seems like that should just happen, I don't want to worry about accidentally removing / when I pass it /tmp

  =back


pkgId: ed44f03a769d9884cb4f1ac6d508176e855a1c91
name: local-perl-File-ShareDir
arch: src
version: 1.03
epoch: 0
release: 1
summary: File-ShareDir - Locate per-dist and per-module shared files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Adam Kennedy <adamk@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-ShareDir-1.03-1.src.rpm
checksum_type: sha
description:
  The intent of L<File::ShareDir> is to provide a companion to
  L<Class::Inspector> and L<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.

  Another method is to put the data "file" after the __DATA__ compiler
  tag and limit yourself to access as a filehandle.

  The problem to solve is really quite simple.

    1. Write the data files to the system at install time.

    2. Know where you put them at run-time.

  Perl's install system creates an "auto" directory for both
  every distribution and for every module file.

  These are used by a couple of different auto-loading systems
  to store code fragments generated at install time, and various
  other modules written by the Perl "ancient masters".

  But the same mechanism is available to any dist or module to
  store any sort of data.


pkgId: e8bd78dab4fc577fcfaf025e7bb9bac202d6846a
name: local-perl-File-Slurp
arch: src
version: 9999.13
epoch: 0
release: 1
summary: File-Slurp - Efficient Reading/Writing of Complete Files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Uri Guttman <uri@stemsystems.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Slurp-9999.13-1.src.rpm
checksum_type: sha
description:
  This module provides subs that allow you to read or write entire files
  with one simple call. They are designed to be simple to use, have
  flexible ways to pass in or get the file contents and to be very
  efficient.  There is also a sub to read in all the files in a
  directory other than C<.> and C<..>

  These slurp/spew subs work for files, pipes and
  sockets, and stdio, pseudo-files, and DATA.


pkgId: f8c7367b78d86965006b1ae803b420dafe4d0cd5
name: local-perl-File-Spec
arch: src
version: 0.7
epoch: 0
release: 1
summary: File-Spec - portably perform operations on file names
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Kenneth Albanowski <Fkjahds@kjahds.com,>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Spec-0.7-1.src.rpm
checksum_type: sha
description:
  This module is designed to support operations commonly performed on file
  specifications (usually called "file names", but not to be confused with the
  contents of a file, or Perl's file handles), such as concatenating several
  directory and file names into a single path, or determining whether a path
  is rooted. It is based on code directly taken from MakeMaker 5.17, code
  written by Andreas KE<ouml>nig, Andy Dougherty, Charles Bailey, Ilya
  Zakharevich, Paul Schinder, and others.

  Since these functions are different for most operating systems, each set of
  OS specific routines is available in a separate module, including:

  	File::Spec::Unix
  	File::Spec::Mac
  	File::Spec::OS2
  	File::Spec::Win32
  	File::Spec::VMS

  The module appropriate for the current OS is automatically loaded by
  File::Spec. Since some modules (like VMS) make use of facilities only under
  that OS, it may not be possible to load all modules under all operating
  systems.

  Since File::Spec is object oriented, subroutines should not called directly,
  as in:

  	File::Spec::catfile('a','b');

  but rather as class methods:

  	File::Spec->catfile('a','b');

  Alternatively, File::Spec::Functions can be used instead, which exports
  functions for all of the class methods provided by File::Spec, including
  catfile, so you may say:

  	use File::Spec::Functions;

  	catfile('a','b');

  For a reference of available functions, pleaes consult L<File::Spec::Unix>,
  which contains the entire set, and which is inherited by the modules for
  other platforms. For further information, please see L<File::Spec::Mac>,
  L<File::Spec::OS2>, L<File::Spec::Win32>, or L<File::Spec::VMS>.


pkgId: 328868df0150a583c5845920b37dc9e509653013
name: local-perl-File-Tail
arch: src
version: 0.99.3
epoch: 0
release: 1
summary: File-Tail - Perl extension for reading from continously updated files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Matija Grabnar <matija.grabnar@arnes.si>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Tail-0.99.3-1.src.rpm
checksum_type: sha
description:
  The primary purpose of File::Tail is reading and analysing log files while
  they are being written, which is especialy usefull if you are monitoring
  the logging process with a tool like Tobias Oetiker's MRTG.

  The module tries very hard NOT to "busy-wait" on a file that has little
  traffic. Any time it reads new data from the file, it counts the number
  of new lines, and divides that number by the time that passed since data
  were last written to the file before that. That is considered the average
  time before new data will be written. When there is no new data to read,
  C<File::Tail> sleeps for that number of seconds. Thereafter, the waiting
  time is recomputed dynamicaly. Note that C<File::Tail> never sleeps for
  more than the number of seconds set by C<maxinterval>.

  If the file does not get altered for a while, C<File::Tail> gets suspicious
  and startschecking if the file was truncated, or moved and recreated. If
  anything like that had happened, C<File::Tail> will quietly reopen the file,
  and continue reading. The only way to affect what happens on reopen is by
  setting the reset_tail parameter (see below). The effect of this is that
  the scripts need not be aware when the logfiles were rotated, they will
  just quietly work on.

  Note that the sleep and time used are from Time::HiRes, so this module
  should do the right thing even if the time to sleep is less than one second.

  The logwatch script (also included) demonstrates several ways of calling
  the methods.


pkgId: b1690ceb51adf5eee2687f89270394a40a014f0c
name: local-perl-File-Temp
arch: src
version: 0.22
epoch: 0
release: 1
summary: File-Temp - return name and handle of a temporary file safely
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tim Jenness <tjenness@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Temp-0.22-1.src.rpm
checksum_type: sha
description:
  C<File::Temp> can be used to create and open temporary files in a safe
  way.  There is both a function interface and an object-oriented
  interface.  The File::Temp constructor or the tempfile() function can
  be used to return the name and the open filehandle of a temporary
  file.  The tempdir() function can be used to create a temporary
  directory.

  The security aspect of temporary file creation is emphasized such that
  a filehandle and filename are returned together.  This helps guarantee
  that a race condition can not occur where the temporary file is
  created by another process between checking for the existence of the
  file and its opening.  Additional security levels are provided to
  check, for example, that the sticky bit is set on world writable
  directories.  See L<"safe_level"> for more information.

  For compatibility with popular C library functions, Perl implementations of
  the mkstemp() family of functions are provided. These are, mkstemp(),
  mkstemps(), mkdtemp() and mktemp().

  Additionally, implementations of the standard L<POSIX|POSIX>
  tmpnam() and tmpfile() functions are provided if required.

  Implementations of mktemp(), tmpnam(), and tempnam() are provided,
  but should be used with caution since they return only a filename
  that was valid when function was called, so cannot guarantee
  that the file will not exist by the time the caller opens the filename.

  Filehandles returned by these functions support the seekable methods.


pkgId: 13d51a9eacefd6d976c525e580b0ca6173140c9d
name: local-perl-File-Which
arch: src
version: 0.05
epoch: 0
release: 1
summary: File-Which - Portable implementation of the `which' utility
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Per Einar Ellefsen <per.einar (at) skynet.be>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-File-Which-0.05-1.src.rpm
checksum_type: sha
description:
  C<File::Which> was created to be able to get the paths to executable programs
  on systems under which the `which' program wasn't implemented in the shell.

  C<File::Which> searches the directories of the user's C<PATH> (as returned by
  C<File::Spec-E<gt>path()>), looking for executable files having the name specified
  as a parameter to C<which()>. Under Win32 systems, which do not have a notion of
  directly executable files, but uses special extensions such as C<.exe> and
  C<.bat> to identify them, C<File::Which> takes extra steps to assure that you
  will find the correct file (so for example, you might be searching for C<perl>,
  it'll try C<perl.exe>, C<perl.bat>, etc.)


pkgId: 628b868d2e42f072d86a2237c0ec40f245936b17
name: local-perl-Filesys-Notify-Simple
arch: src
version: 0.08
epoch: 0
release: 1
summary: Filesys-Notify-Simple - Simple and dumb file system watcher
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tatsuhiko Miyagawa <miyagawa@bulknews.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Filesys-Notify-Simple-0.08-1.src.rpm
checksum_type: sha
description:
  Filesys::Notify::Simple is a simple but unified interface to get
  notifications of changes to a given filesystem path. It utilizes
  inotify2 on Linux and fsevents on OS X if they're installed, with a
  fallback to the full directory scan if they're not available.

  There are some limitations in this module. If you don't like it, use
  L<File::ChangeNotify>.

  =over 4

  =item *

  There is no file name based filter. Do it in your own code.

  =item *

  You can not get types of events (created, updated, deleted).

  =item *

  Currently C<wait> method blocks.

  =back

  In return, this module doesn't depend on any non-core
  modules. Platform specific optimizations with L<Linux::Inotify2> and
  L<Mac::FSEvents> are truely optional.


pkgId: dcf70b1a04d4adde8994de955bf023f00a4774c3
name: local-perl-Font-AFM
arch: src
version: 1.20
epoch: 0
release: 1
summary: Font-AFM - Interface to Adobe Font Metrics files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: gaas@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Font-AFM-1.20-1.src.rpm
checksum_type: sha
description:
  This module implements the Font::AFM class. Objects of this class are
  initialised from an AFM (Adobe Font Metrics) file and allow you to obtain information
  about the font and the metrics of the various glyphs in the font.

  All measurements in AFM files are given in terms of units equal to
  1/1000 of the scale factor of the font being used. To compute actual
  sizes in a document, these amounts should be multiplied by (scale
  factor of font)/1000.

  The following methods are available:

  =over 3

  =item $afm = Font::AFM->new($fontname)

  Object constructor. Takes the name of the font as argument.
  Croaks if the font can not be found.

  =item $afm->latin1_wx_table()

  Returns a 256-element array, where each element contains the width
  of the corresponding character in the iso-8859-1 character set.

  =item $afm->stringwidth($string, [$fontsize])

  Returns the width of the argument string. The string is
  assumed to be encoded in the iso-8859-1 character set.  A second
  argument can be used to scale the width according to the font size.

  =item $afm->FontName

  The name of the font as presented to the PostScript language
  C<findfont> operator, for instance "Times-Roman".

  =item $afm->FullName

  Unique, human-readable name for an individual font, for instance
  "Times Roman".

  =item $afm->FamilyName

  Human-readable name for a group of fonts that are stylistic variants
  of a single design. All fonts that are members of such a group should
  have exactly the same C<FamilyName>. Example of a family name is
  "Times".

  =item $afm->Weight

  Human-readable name for the weight, or "boldness", attribute of a font.
  Examples are C<Roman>, C<Bold>, C<Light>.

  =item $afm->ItalicAngle

  Angle in degrees counterclockwise from the vertical of the dominant
  vertical strokes of the font.

  =item $afm->IsFixedPitch

  If C<true>, the font is a fixed-pitch
  (monospaced) font.

  =item $afm->FontBBox

  A string of four numbers giving the lower-left x, lower-left y,
  upper-right x, and upper-right y of the font bounding box. The font
  bounding box is the smallest rectangle enclosing the shape that would
  result if all the characters of the font were placed with their
  origins coincident, and then painted.

  =item $afm->UnderlinePosition

  Recommended distance from the baseline for positioning underline
  strokes. This number is the y coordinate of the center of the stroke.

  =item $afm->UnderlineThickness

  Recommended stroke width for underlining.

  =item $afm->Version

  Version number of the font.

  =item $afm->Notice

  Trademark or copyright notice, if applicable.

  =item $afm->Comment

  Comments found in the AFM file.

  =item $afm->EncodingScheme

  The name of the standard encoding scheme for the font. Most Adobe
  fonts use the C<AdobeStandardEncoding>. Special fonts might state
  C<FontSpecific>.

  =item $afm->CapHeight

  Usually the y-value of the top of the capital H.

  =item $afm->XHeight

  Typically the y-value of the top of the lowercase x.

  =item $afm->Ascender

  Typically the y-value of the top of the lowercase d.

  =item $afm->Descender

  Typically the y-value of the bottom of the lowercase p.

  =item $afm->Wx

  Returns a hash table that maps from glyph names to the width of that glyph.

  =item $afm->BBox

  Returns a hash table that maps from glyph names to bounding box information.
  The bounding box consist of four numbers: llx, lly, urx, ury.

  =item $afm->dump

  Dumps the content of the Font::AFM object to STDOUT.  Might sometimes
  be useful for debugging.

  =back


  The AFM specification can be found at:

     http://partners.adobe.com/asn/developer/pdfs/tn/5004.AFM_Spec.pdf


pkgId: a33a8f20e806e4e881154d7746432e883a4862d2
name: local-perl-FreezeThaw
arch: src
version: 0.43
epoch: 0
release: 1
summary: FreezeThaw - converting Perl structures to strings and back.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: ILYAZ
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-FreezeThaw-0.43-1.src.rpm
checksum_type: sha
description:
  Converts data to/from stringified form, appropriate for
  saving-to/reading-from permanent storage.

  Deals with objects, circular lists, repeated appearence of the same
  refence. Does not deal with overloaded I<stringify> operator yet.


pkgId: 2e60bf77fb87f907ef16d9874aad6e4917df6e44
name: local-perl-GD
arch: src
version: 2.39
epoch: 0
release: 1
summary: GD - Interface to Gd Graphics Library
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Lincoln Stein (lstein@cshl.org)
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-GD-2.39-1.src.rpm
checksum_type: sha
description:
  B<GD.pm> is a Perl interface to Thomas Boutell's gd graphics library
  (version 2.01 or higher; see below). GD allows you to create color
  drawings using a large number of graphics primitives, and emit the
  drawings as PNG files.

  GD defines the following four classes:

  =over 5


  =item C<GD::Image>

  An image class, which holds the image data and accepts graphic
  primitive method calls.

  =item C<GD::Font>

  A font class, which holds static font information and used for text
  rendering.

  =item C<GD::Polygon>

  A simple polygon object, used for storing lists of vertices prior to
  rendering a polygon into an image.

  =item C<GD::Simple>

  A "simple" class that simplifies the GD::Image API and then adds a set
  of object-oriented drawing methods using turtle graphics, simplified
  font handling, ability to work in polar coordinates, HSV color spaces,
  and human-readable color names like "lightblue". Please see
  L<GD::Simple> for a description of these methods.

  =back

  A Simple Example:

  	

  	use GD;

  	
  	$im = new GD::Image(100,100);

  	
  	$white = $im->colorAllocate(255,255,255);
  	$black = $im->colorAllocate(0,0,0);
  	$red = $im->colorAllocate(255,0,0);
  	$blue = $im->colorAllocate(0,0,255);

  	
  	$im->transparent($white);
  	$im->interlaced('true');

  	
  	$im->rectangle(0,0,99,99,$black);

  	
  	$im->arc(50,50,95,75,0,360,$blue);

  	
  	$im->fill(50,50,$red);

  	
  	binmode STDOUT;

  	
  	print $im->png;

  Notes:

  =over 5

  =item 1.
  To create a new, empty image, send a new() message to GD::Image, passing
  it the width and height of the image you want to create.  An image
  object will be returned.  Other class methods allow you to initialize
  an image from a preexisting JPG, PNG, GD, GD2 or XBM file.

  =item 2.
  Next you will ordinarily add colors to the image's color table.
  colors are added using a colorAllocate() method call.  The three
  parameters in each call are the red, green and blue (rgb) triples for
  the desired color.  The method returns the index of that color in the
  image's color table.  You should store these indexes for later use.

  =item 3.
  Now you can do some drawing!  The various graphics primitives are
  described below.  In this example, we do some text drawing, create an
  oval, and create and draw a polygon.

  =item 4.
  Polygons are created with a new() message to GD::Polygon.  You can add
  points to the returned polygon one at a time using the addPt() method.
  The polygon can then be passed to an image for rendering.

  =item 5.
  When you're done drawing, you can convert the image into PNG format by
  sending it a png() message.  It will return a (potentially large)
  scalar value containing the binary data for the image.  Ordinarily you
  will print it out at this point or write it to a file.  To ensure
  portability to platforms that differentiate between text and binary
  files, be sure to call C<binmode()> on the file you are writing
  the image to.

  =back


pkgId: 3056f5bfd1420bac95ab668afc59ad42d5f14388
name: local-perl-GD-Barcode
arch: src
version: 1.15
epoch: 0
release: 1
summary: GD-Barcode - Create barcode image with GD
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Kawai Takanori <GCD00051@nifty.ne.jp>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-GD-Barcode-1.15-1.src.rpm
checksum_type: sha
description:
  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).


pkgId: 35eb8706362450ecc549a9cfd174f28dda8c4045
name: local-perl-GDGraph
arch: src
version: 1.44_01
epoch: 0
release: 1
summary: GDGraph - Produces charts with GD
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Martien Verbruggen <mgjv@tradingpost.com.au>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-GDGraph-1.44_01-1.src.rpm
checksum_type: sha
description:
  B<GD::Graph> is a I<perl5> module to create charts using the GD module.
  The following classes for graphs with axes are defined:

  =over 4

  =item C<GD::Graph::lines>

  Create a line chart.

  =item C<GD::Graph::bars> and C<GD::Graph::hbars>

  Create a bar chart with vertical or horizontal bars.

  =item C<GD::Graph::points>

  Create an chart, displaying the data as points.

  =item C<GD::Graph::linespoints>

  Combination of lines and points.

  =item C<GD::Graph::area>

  Create a graph, representing the data as areas under a line.

  =item C<GD::Graph::mixed>

  Create a mixed type graph, any combination of the above. At the moment
  this is fairly limited. Some of the options that can be used with some
  of the individual graph types won't work very well. Bar graphs drawn
  after lines or points graphs may obscure the earlier data, and
  specifying bar_width will not produce the results you probably expected.

  =back

  Additional types:

  =over 4

  =item C<GD::Graph::pie>

  Create a pie chart.

  =back


pkgId: 8c7c04e78ea467da9cb0da90ecb14362218d4d6f
name: local-perl-GDTextUtil
arch: src
version: 0.86
epoch: 0
release: 1
summary: GDTextUtil - text utilities for GD
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Martien Verbruggen (mgjv@comdyn.com.au)
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-GDTextUtil-0.86-1.src.rpm
checksum_type: sha
description:
  This module provides a font-independent way of dealing with text in
  GD, for use with the GD::Text::* modules and GD::Graph.


pkgId: 3cf64cbe3d21390d208fc12c5c3b0e3c8e3e09ed
name: local-perl-GPG
arch: src
version: 0.05
epoch: 0
release: 1
summary: GPG - Perl Interface to GnuPG (http://www.gnupg.org)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Philippe Froidevaux (miles@users.sourceforge.net)
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-GPG-0.05-1.src.rpm
checksum_type: sha
description:
  GPG.pm is a Perl5 interface for using GnuPG. GPG works with $scalar (string),
  as opposed to the existing Perl5 modules (GnuPG.pm and GnuPG::Interface, which
  communicate with gnupg through filehandles or filenames)


pkgId: eca2a7c59e684bc931ba5a6e4e86d9060fe7fcab
name: local-perl-GSSAPI
arch: src
version: 0.26
epoch: 0
release: 1
summary: Perl extension providing access to the GSSAPIv2 library
url: http://search.cpan.org/dist/GSSAPI/
rpm_license: GPL+ or Artistic
rpm_group: Development/Libraries
rpm_buildhost: sl4-rhel5-build64.endpoint.com
location_href: local-perl-GSSAPI-0.26-1.src.rpm
checksum_type: sha
description:
  This module gives access to the routines of the GSSAPI library, as
  described in rfc2743 and rfc2744 and implemented by the Kerberos-1.2
  distribution from MIT.


pkgId: e0447c119da30d28f1f0b19985151658aca5e73b
name: local-perl-Geo-IP
arch: src
version: 1.35
epoch: 0
release: 1
summary: Geo-IP - Look up location and network information by IP Address
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Copyright c <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Geo-IP-1.35-1.src.rpm
checksum_type: sha
description:
  This module uses a file based database.  This database simply contains
  IP blocks as keys, and countries as values.
  This database should be more
  complete and accurate than reverse DNS lookups.

  This module can be used to automatically select the geographically closest mirror,
  to analyze your web server logs
  to determine the countries of your visitors, for credit card fraud
  detection, and for software export controls.


pkgId: 09a52c33800204c838b56b851963ccf260371c45
name: local-perl-Glib
arch: src
version: 1.222
epoch: 0
release: 1
summary: Glib - Perl wrappers for the GLib utility and Object libraries
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Glib-1.222-1.src.rpm
checksum_type: sha
description:
  This wrapper attempts to provide a perlish interface while remaining
  as true as possible to the underlying C API, so that any reference
  materials you can find on using GLib may still apply to using the
  libraries from perl.  This module also provides facilities for creating
  wrappers for other GObject-based libraries.  The L<SEE ALSO> section
  contains pointers to all sorts of good information.


pkgId: c1ea9b9313ca90af250b7fe4d43be78ae21d62bd
name: local-perl-GnuPG-Interface
arch: src
version: 0.36
epoch: 0
release: 2
summary: GnuPG-Interface - supply object methods for interacting with GnuPG
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Frank J. Tobin
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-GnuPG-Interface-0.36-2.src.rpm
checksum_type: sha
description:
  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.


pkgId: f01b026f875463e1362382279076984b27448089
name: local-perl-GraphViz
arch: src
version: 2.03
epoch: 0
release: 1
summary: GraphViz - Interface to the GraphViz graphing tool
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Leon Brocard <EltFacme@astray.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-GraphViz-2.03-1.src.rpm
checksum_type: sha
description:
  This module provides an interface to layout and image generation of directed
  and undirected graphs in a variety of formats (PostScript, PNG, etc.) using the
  "dot", "neato", "twopi", "circo" and "fdp"  programs from the GraphViz project
  (http://www.graphviz.org/ or http://www.research.att.com/sw/tools/graphviz/).


pkgId: a3fcf0d737c98679f8ee2acd712ded5363d9adb7
name: local-perl-HTML-CalendarMonthSimple
arch: src
version: 1.25
epoch: 0
release: 1
summary: HTML-CalendarMonthSimple - Perl Module for Generating HTML Calendars
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: stigmata@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-CalendarMonthSimple-1.25-1.src.rpm
checksum_type: sha
description:
  HTML::CalendarMonthSimple is a Perl module for generating, manipulating, and printing a HTML calendar grid for a specified month. It is intended as a faster and easier-to-use alternative to HTML::CalendarMonth.

  This module requires the Date::Calc module, which is available from CPAN if you don't already have it.


pkgId: da1498dce205e7609df38acce20ccfcb9dee0fd2
name: local-perl-HTML-FillInForm
arch: src
version: 2.00
epoch: 0
release: 1
summary: HTML-FillInForm - Populates HTML Forms with data.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: TJ Mather <tjmather@maxmind.com,>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-FillInForm-2.00-1.src.rpm
checksum_type: sha
description:
  This module fills in an HTML form with data from a Perl data structure, allowing you
  to keep the HTML and Perl separate.

  Here are two common use cases:

  1. A user submits an HTML form without filling out a required field.  You want
  to redisplay the form with all the previous data in it, to make it easy for the
  user to see and correct the error.

  2. You have just retrieved a record from a database and need to display it in
  an HTML form.


pkgId: bd57efb3e0d0b3fdcd750a716c6374cc122d76d9
name: local-perl-HTML-Format
arch: src
version: 0.2
epoch: 0
release: 1
summary: HTML-Format - Format Perl data structures into simple HTML
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David Moreno Garza <Eltdamogar@gmail.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Format-0.2-1.src.rpm
checksum_type: sha
description:
  use HTML::Format;

   my $f = HTML::Format->new;

   my %hash = (simple => 'hash');

   
   
   my $struct = {
   	foo 				=> 'bar',
   	1 					=> 2,
   	\'hello' 			=> 'goodbye',
   	array_ref			=> [qw/one two three/],
   	nested_hash			=> \%hash,
   	[qw/1 2/]			=> sub { die; },
   	even_more			=> { arr => {
   			1 => [2, 3, 4],
   			this_is_insane => { a => { b => { c => { d => { e => 'z'}}}}}
   		},
   	},
   };

   $struct->{'HTML::Format handles it all'} = $f;

   print $f->format();

  And that will output the following insane, but possible, for the sake
  of showing, HTML:

  =begin HTML

  <table border="1" class="hashTable">
  <tr><th>SCALAR(0x82a2be4)</th><td>goodbye</td></tr>

  <tr><th>ARRAY(0x8225570)</th><td><p class="code">CODE(0x8370ac8)</p>
  </td></tr>
  <tr><th>1</th><td>2</td></tr>
  <tr><th>array_ref</th><td><table border="1" class="arrayTable">
  <tr><td>one</td></tr>
  <tr><td>two</td></tr>
  <tr><td>three</td></tr>
  </table>
  </div>

  </td></tr>
  <tr><th>nested_hash</th><td><table border="1" class="hashTable">
  <tr><th>simple</th><td>hash</td></tr>
  </table>

  </td></tr>
  <tr><th>foo</th><td>bar</td></tr>
  <tr><th>HTML::Format handles it all</th><td><p class="scalar">HTML::Format=HASH(0x82255c4)</p>

  </td></tr>
  <tr><th>even_more</th><td><table border="1" class="hashTable">
  <tr><th>arr</th><td><table border="1" class="hashTable">
  <tr><th>1</th><td><table border="1" class="arrayTable">
  <tr><td>2</td></tr>
  <tr><td>3</td></tr>
  <tr><td>4</td></tr>
  </table>
  </div>

  </td></tr>

  <tr><th>this_is_insane</th><td><table border="1" class="hashTable">
  <tr><th>a</th><td><table border="1" class="hashTable">
  <tr><th>b</th><td><table border="1" class="hashTable">
  <tr><th>c</th><td><table border="1" class="hashTable">
  <tr><th>d</th><td><table border="1" class="hashTable">
  <tr><th>e</th><td>z</td></tr>
  </table>

  </td></tr>
  </table>

  </td></tr>
  </table>

  </td></tr>
  </table>

  </td></tr>
  </table>

  </td></tr>
  </table>

  </td></tr>
  </table>

  </td></tr>

  </table>

  =end HTML

  In theory you can pass any kind of Perl data structure to C<format>
  and you will get its data HTML-formatted.


pkgId: 6a4214bbfc00f29e7b0cbfd4e66af41eebab2e6e
name: local-perl-HTML-Format
arch: src
version: 2.04
epoch: 0
release: 1
summary: HTML-Format - Base class for HTML formatters
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Sean M Burke <sburke@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Format-2.04-1.src.rpm
checksum_type: sha
description:
  HTML::Formatter is a base class for classes that take HTML
  and format it to some output format.  When you take an object
  of such a base class and call C<< $formatter->format( $tree ) >>
  with an HTML::TreeBuilder (or HTML::Element) object, they return
  the

  HTML formatters are able to format a HTML syntax tree into various
  printable formats.  Different formatters produce output for different
  output media.  Common for all formatters are that they will return the
  formatted output when the format() method is called.  The format()
  method takes a HTML::Element object (usually the HTML::TreeBuilder
  root object) as parameter.

  Here are the four main methods that this class provides:

  =over

  =item SomeClass->format_file( $filename, I<< option1 => value1, option2 => value2, ... >> )

  This returns a string consisting of the result of using the given class
  to format the given HTML file according to the given (optional) options.
  Internally it calls C<< SomeClass->new( ... )->format( ... ) >> on a new
  HTML::TreeBuilder object based on the given HTML file.

  =item SomeClass->format_string( $html_source, I<< option1 => value1, option2 => value2, ... >> )

  This returns a string consisting of the result of using the given class
  to format the given HTML source according to the given (optional)
  options. Internally it calls C<< SomeClass->new( ... )->format( ... ) >>
  on a new HTML::TreeBuilder object based on the given source.

  =item $formatter = SomeClass->new( I<< option1 => value1, option2 => value2, ... >> )

  This creates a new formatter object with the given options.

  =item $render_string = $formatter->format( $html_tree_object )

  This renders the given HTML object accerting to the options set for
  $formatter.

  =back


  After you've used a particular formatter object to format a particular
  HTML tree object, you probably should not use either again.


pkgId: 79e0874483ff6e2fc0aeb3c90360e1922512ed0a
name: local-perl-HTML-HTMLDoc
arch: src
version: 0.10
epoch: 0
release: 1
summary: HTML-HTMLDoc - Perl interface to the htmldoc program for producing PDF-Files from HTML-Content
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michael Frankl <mfrankl@seibert-media.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-HTMLDoc-0.10-1.src.rpm
checksum_type: sha
description:
  This Module provides an OO-interface to the htmldoc programm. To install this module you
  have to install the htmldoc program first. You can get it from http://www.htmldoc.org .

  You can use it to produce PDF or PS files from a HTML-document. Currently many but not all
  parameters of HTMLDoc are supported.

  You need to have HTMLDoc installed before installing this module.

  All the pdf-Methods return true for success or false for failure. You can test if errors
  occurred by calling the error-method.

  Normaly this module uses IPC::Open3 for communacation with the HTMLDOC process. However,
  in mod_perl-environments there appear problems with this module because the standard-output can not
  be captured. For this problem this module provides a fix doing the communication in file-mode.

  For this you can specify the parameter mode in the constructor:
  my $htmldoc = new HTMLDoc('mode'=>'file', 'tmpdir'=>'/tmp');


pkgId: b20f71ae26ca007367796d95386c5904387b468f
name: local-perl-HTML-Lint
arch: src
version: 2.04
epoch: 0
release: 1
summary: HTML-Lint - check for HTML errors in a string or file
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andy Lester <andy@petdance.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Lint-2.04-1.src.rpm
checksum_type: sha
description:
  my $lint = HTML::Lint->new;
      $lint->only_types( HTML::Lint::STRUCTURE );

      $lint->parse( $data );
      $lint->parse_file( $filename );

      my $error_count = $lint->errors;

      foreach my $error ( $lint->errors ) {
          print $error->as_string, "\n";
      }

  HTML::Lint also comes with a wrapper program called F<weblint> that handles
  linting from the command line:

      $ weblint http://www.cnn.com/
      http://www.cnn.com/ (395:83) <IMG SRC="spacer.gif"> tag has no HEIGHT and WIDTH attributes.
      http://www.cnn.com/ (395:83) <IMG SRC="goofus.gif"> does not have ALT text defined
      http://www.cnn.com/ (396:217) Unknown element <nobr>
      http://www.cnn.com/ (396:241) </nobr> with no opening <nobr>
      http://www.cnn.com/ (842:7) target attribute in <a> is repeated

  And finally, you can also get L<Apache::HTML::Lint> that passes any
  mod_perl-generated code through HTML::Lint and get it dumped into your
  Apache F<error_log>.

      [Mon Jun  3 14:03:31 2002] [warn] /foo.pl (1:45) </p> with no opening <p>
      [Mon Jun  3 14:03:31 2002] [warn] /foo.pl (1:49) Unknown element <gronk>
      [Mon Jun  3 14:03:31 2002] [warn] /foo.pl (1:56) Unknown attribute "x" for tag <table>


pkgId: f94d3c0037590f3ce95cbc47e16807a82f9530a1
name: local-perl-HTML-Parser
arch: src
version: 3.56
epoch: 0
release: 1
summary: HTML-Parser - HTML parser class
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: gaas@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Parser-3.56-1.src.rpm
checksum_type: sha
description:
  Objects of the C<HTML::Parser> class will recognize markup and
  separate it from plain text (alias data content) in HTML
  documents.  As different kinds of markup and text are recognized, the
  corresponding event handlers are invoked.

  C<HTML::Parser> is not a generic SGML parser.  We have tried to
  make it able to deal with the HTML that is actually "out there", and
  it normally parses as closely as possible to the way the popular web
  browsers do it instead of strictly following one of the many HTML
  specifications from W3C.  Where there is disagreement, there is often
  an option that you can enable to get the official behaviour.

  The document to be parsed may be supplied in arbitrary chunks.  This
  makes on-the-fly parsing as documents are received from the network
  possible.

  If event driven parsing does not feel right for your application, you
  might want to use C<HTML::PullParser>.  This is an C<HTML::Parser>
  subclass that allows a more conventional program structure.


pkgId: 74a4746b03db1d16f3bd9e423f1d4e4c0f056a02
name: local-perl-HTML-Scrubber
arch: src
version: 0.08
epoch: 0
release: 1
summary: HTML-Scrubber - Perl extension for scrubbing/sanitizing html
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: D. H. aka PodMaster
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Scrubber-0.08-1.src.rpm
checksum_type: sha
description:
  If you wanna "scrub" or "sanitize" html input
  in a reliable an flexible fashion,
  then this module is for you.

  I wasn't satisfied with HTML::Sanitizer because it is
  based on HTML::TreeBuilder,
  so I thought I'd write something similar
  that works directly with HTML::Parser.


pkgId: 94a86c957ce87692627e87d7df8ea9d2bfb2fcdd
name: local-perl-HTML-Strip
arch: src
version: 1.06
epoch: 0
release: 1
summary: HTML-Strip - Perl extension for stripping HTML markup from text.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Alex Bowley <kilinrax@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Strip-1.06-1.src.rpm
checksum_type: sha
description:
  This module simply strips HTML-like markup from text in a very quick
  and brutal manner. It could quite easily be used to strip XML or SGML
  from text as well; but removing HTML markup is a much more common
  problem, hence this module lives in the HTML:: namespace.

  It is written in XS, and thus about five times quicker than using
  regular expressions for the same task.

  It does I<not> do any syntax checking (if you want that, use
  L<HTML::Parser>), instead it merely applies the following rules:

  =over 4

  =item 1

  Anything that looks like a tag, or group of tags will be replaced with
  a single space character. Tags are considered to be anything that
  starts with a C<E<lt>> and ends with a C<E<gt>>; with the caveat that a
  C<E<gt>> character may appear in either of the following without
  ending the tag:

  =over 4

  =item Quote

  Quotes are considered to start with either a C<'> or a C<"> character,
  and end with a matching character I<not> preceded by an even number or
  escaping slashes (i.e. C<\"> does not end the quote but C<\\\\"> does).

  =item Comment

  If the tag starts with an exclamation mark, it is assumed to be a
  declaration or a comment. Within such tags, C<E<gt>> characters do not
  end the tag if they appear within pairs of double dashes (e.g. C<E<lt>!--
  E<lt>a href="old.htm"E<gt>old pageE<lt>/aE<gt> --E<gt>> would be
  stripped completely).

  =back

  =item 2

  Anything the appears within so-called I<strip tags> is stripped as
  well. By default, these tags are C<title>, C<script>, C<style> and
  C<applet>.

  =back

  HTML::Strip maintains state between calls, so you can parse a document
  in chunks should you wish. If one chunk ends half-way through a tag,
  quote, comment, or whatever; it will remember this, and expect the
  next call to parse to start with the remains of said tag.

  If this is not going to be the case, be sure to call $hs->eof()
  between calls to $hs->parse().


pkgId: 750f2eca25684c213d8b2742bb74a442d4d37a65
name: local-perl-HTML-TagParser
arch: src
version: 0.16
epoch: 0
release: 1
summary: HTML-TagParser - Yet another HTML document parser with DOM-like methods
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Yusuke Kawasaki httpwwwkawanet <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-TagParser-0.16-1.src.rpm
checksum_type: sha
description:
  HTML::TagParser is a pure Perl module which parses HTML/XHTML files.
  This module provides some methods like DOM interface.
  This module is not strict about XHTML format
  because many of HTML pages are not strict.
  You know, many pages use <br> elemtents instead of <br/>
  and have <p> elements which are not closed.


pkgId: 5820dc63faa51ab11cc1a8ca7250692de676e84f
name: local-perl-HTML-Tagset
arch: src
version: 3.20
epoch: 0
release: 1
summary: HTML-Tagset - data tables useful in parsing HTML
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andy Lester <andy@petdance.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Tagset-3.20-1.src.rpm
checksum_type: sha
description:
  This module contains several data tables useful in various kinds of
  HTML parsing operations.

  Note that all tag names used are lowercase.

  In the following documentation, a "hashset" is a hash being used as a
  set -- the hash conveys that its keys are there, and the actual values
  associated with the keys are not significant.  (But what values are
  there, are always true.)


pkgId: 5547ec7b3f20fa34fa055ea98aed4f675bc9cd3d
name: local-perl-HTML-Template
arch: src
version: 2.9
epoch: 0
release: 1
summary: HTML-Template - Perl module to use HTML Templates from CGI scripts
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Sam Tregar <sam@tregar.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Template-2.9-1.src.rpm
checksum_type: sha
description:
  This module attempts to make using HTML templates simple and natural.
  It extends standard HTML with a few new HTML-esque tags - <TMPL_VAR>,
  <TMPL_LOOP>, <TMPL_INCLUDE>, <TMPL_IF>, <TMPL_ELSE> and <TMPL_UNLESS>.
  The file written with HTML and these new tags is called a template.
  It is usually saved separate from your script - possibly even created
  by someone else!  Using this module you fill in the values for the
  variables, loops and branches declared in the template.  This allows
  you to separate design - the HTML - from the data, which you generate
  in the Perl script.

  This module is licensed under the GPL.  See the LICENSE section
  below for more details.


pkgId: 13bdf3f546b8fddb61f6e9c20e8876434a8e7050
name: local-perl-HTML-Tidy
arch: src
version: 1.56
epoch: 0
release: 1
summary: HTML-Tidy - (X)HTML validation in a Perl object
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andy Lester <andy@petdance.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Tidy-1.56-1.src.rpm
checksum_type: sha
description:
  C<HTML::Tidy> is an HTML checker in a handy dandy object.  It's meant as
  a replacement for L<HTML::Lint|HTML::Lint>.  If you're currently an L<HTML::Lint|HTML::Lint>
  user looking to migrate, see the section L</Converting from HTML::Lint>.


pkgId: df29bb74abc1f598b5912eff86eb9bd009cd9ed0
name: local-perl-HTML-Tree
arch: src
version: 3.23
epoch: 0
release: 1
summary: HTML-Tree - build and scan parse-trees of HTML
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Pete Krawczyk <petek@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTML-Tree-3.23-1.src.rpm
checksum_type: sha
description:
  HTML-Tree is a suite of Perl modules for making parse trees out of
  HTML source.  It consists of mainly two modules, whose documentation
  you should refer to: L<HTML::TreeBuilder|HTML::TreeBuilder>
  and L<HTML::Element|HTML::Element>.

  HTML::TreeBuilder is the module that builds the parse trees.  (It uses
  HTML::Parser to do the work of breaking the HTML up into tokens.)

  The tree that TreeBuilder builds for you is made up of objects of the
  class HTML::Element.

  If you find that you do not properly understand the documentation
  for HTML::TreeBuilder and HTML::Element, it may be because you are
  unfamiliar with tree-shaped data structures, or with object-oriented
  modules in general. Sean Burke has written some articles for
  I<The Perl Journal> (C<www.tpj.com>) that seek to provide that background.
  The full text of those articles is contained in this distribution, as:

  =over 4

  =item L<HTML::Tree::AboutObjects|HTML::Tree::AboutObjects>

  "User's View of Object-Oriented Modules" from TPJ17.

  =item L<HTML::Tree::AboutTrees|HTML::Tree::AboutTrees>

  "Trees" from TPJ18

  =item L<HTML::Tree::Scanning|HTML::Tree::Scanning>

  "Scanning HTML" from TPJ19

  =back

  Readers already familiar with object-oriented modules and tree-shaped
  data structures should read just the last article.  Readers without
  that background should read the first, then the second, and then the
  third.


pkgId: cdc4f7ac7a2ad6b702b4f472a646ab4609ad1400
name: local-perl-HTTP-Body
arch: src
version: 1.04
epoch: 0
release: 1
summary: HTTP-Body - HTTP Body Parser
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Christian Hansen <Cch@ngmedia.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTTP-Body-1.04-1.src.rpm
checksum_type: sha
description:
  HTTP::Body parses chunks of HTTP POST data and supports
  application/octet-stream, application/x-www-form-urlencoded, and
  multipart/form-data.

  Chunked bodies are supported by not passing a length value to new().

  It is currently used by L<Catalyst> to parse POST bodies.


pkgId: 911a676bcc4953bcc33f6ae73d1626fd1e024b40
name: local-perl-HTTP-Body
arch: src
version: 1.12
epoch: 0
release: 1
summary: HTTP-Body - HTTP Body Parser
description: None.
url: http://www.cpan.org
rpm_license: Artistic
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTTP-Body-1.12-1.src.rpm
checksum_type: sha
rpm_vendor:
  Christian Hansen, C<chansen@cpan.org>, Sebastian Riedel, C<sri@cpan.org>, Andy Grundman, C<andy@hybridized.org>, Torsten Raudssus, C<getty@cpan.org>


pkgId: f7b18ceabc5d20cbe2b402f8d96e5083bfc949b4
name: local-perl-HTTP-BrowserDetect
arch: src
version: 0.99
epoch: 0
release: 1
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Lee Semel <lee@semel.net>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTTP-BrowserDetect-0.99-1.src.rpm
checksum_type: sha
summary:
  HTTP-BrowserDetect - Determine the Web browser, version, and platform from an HTTP user agent string

description:
  The HTTP::BrowserDetect object does a number of tests on an HTTP user
  agent string.  The results of these tests are available via methods of
  the object.

  This module is based upon the JavaScript browser detection code
  available at
  B<http://www.mozilla.org/docs/web-developer/sniffer/browser_type.html>.


pkgId: af3d4f2edacb25b15acdcf0b9b49bf672b6aaf94
name: local-perl-HTTP-Server-Simple
arch: src
version: 0.44
epoch: 0
release: 1
summary: HTTP-Server-Simple - Lightweight HTTP server
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Jesse Vincent <jesse@bestpractical.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTTP-Server-Simple-0.44-1.src.rpm
checksum_type: sha
description:
  This is a simple standalone HTTP server. By default, it doesn't thread
  or fork. It does, however, act as a simple frontend which can be used
  to build a standalone web-based application or turn a CGI into one.

  It is possible to use L<Net::Server> classes to create forking,
  pre-forking, and other types of more complicated servers; see
  L</net_server>.

  By default, the server traps a few signals:

  =over

  =item HUP

  When you C<kill -HUP> the server, it lets the current request finish being
  processed, then uses the C<restart> method to re-exec itself. Please note that
  in order to provide restart-on-SIGHUP, HTTP::Server::Simple sets a SIGHUP
  handler during initialisation. If your request handling code forks you need to
  make sure you reset this or unexpected things will happen if somebody sends a
  HUP to all running processes spawned by your app (e.g. by "kill -HUP <script>")

  =item PIPE

  If the server detects a broken pipe while writing output to the client,
  it ignores the signal. Otherwise, a client closing the connection early
  could kill the server.

  =back


pkgId: 3ecd70431dcab5ee039cd6a06dc8dc04685eb53d
name: local-perl-HTTP-Server-Simple-PSGI
arch: src
version: 0.14
epoch: 0
release: 1
summary: HTTP-Server-Simple-PSGI - PSGI handler for HTTP::Server::Simple
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tokuhiro MatsunoKazuhiro <>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-HTTP-Server-Simple-PSGI-0.14-1.src.rpm
checksum_type: sha
description:
  HTTP::Server::Simple::PSGI is a HTTP::Server::Simple based HTTP server
  that can run PSGI applications. This module only depends on
  L<HTTP::Server::Simple>, which itself doesn't depend on any non-core
  modules so it's best to be used as an embedded web server.


pkgId: fa18cbb73a22d69fa0d5e4e04b3cb11d39a96fd5
name: local-perl-Hash-Merge
arch: src
version: 0.12
epoch: 0
release: 1
summary: Hash-Merge - Merges arbitrarily deep hashes into a single hash
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michael K. Neylon <mneylon-pm@masemware.com
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Hash-Merge-0.12-1.src.rpm
checksum_type: sha
description:
  Hash::Merge merges two arbitrarily deep hashes into a single hash.  That
  is, at any level, it will add non-conflicting key-value pairs from one
  hash to the other, and follows a set of specific rules when there are key
  value conflicts (as outlined below).  The hash is followed recursively,
  so that deeply nested hashes that are at the same level will be merged
  when the parent hashes are merged.  B<Please note that self-referencing
  hashes, or recursive references, are not handled well by this method.>

  Values in hashes are considered to be either ARRAY references,
  HASH references, or otherwise are treated as SCALARs.  By default, the
  data passed to the merge function will be cloned using the Clone module;
  however, if necessary, this behavior can be changed to use as many of
  the original values as possible.  (See C<set_clone_behavior>).

  Because there are a number of possible ways that one may want to merge
  values when keys are conflicting, Hash::Merge provides several preset
  methods for your convenience, as well as a way to define you own.
  These are (currently):

  =over

  =item Left Precedence

  This is the default behavior.

  The values buried in the left hash will never
  be lost; any values that can be added from the right hash will be
  attempted.

     my $merge = Hash::Merge->new();
     my $merge = Hash::Merge->new('LEFT_PRECEDENT');
     $merge->set_set_behavior('LEFT_PRECEDENT')
     Hash::Merge::set_set_behavior('LEFT_PRECEDENT')

  =item Right Precedence

  Same as Left Precedence, but with the right
  hash values never being lost

     my $merge = Hash::Merge->new('RIGHT_PRECEDENT');
     $merge->set_set_behavior('RIGHT_PRECEDENT')
     Hash::Merge::set_set_behavior('RIGHT_PRECEDENT')

  =item Storage Precedence

  If conflicting keys have two different
  storage mediums, the 'bigger' medium will win; arrays are preferred over
  scalars, hashes over either.  The other medium will try to be fitted in
  the other, but if this isn't possible, the data is dropped.

     my $merge = Hash::Merge->new('STORAGE_PRECEDENT');
     $merge->set_set_behavior('STORAGE_PRECEDENT')
     Hash::Merge::set_set_behavior('STORAGE_PRECEDENT')

  =item Retainment Precedence

  No data will be lost; scalars will be joined
  with arrays, and scalars and arrays will be 'hashified' to fit them into
  a hash.

     my $merge = Hash::Merge->new('RETAINMENT_PRECEDENT');
     $merge->set_set_behavior('RETAINMENT_PRECEDENT')
     Hash::Merge::set_set_behavior('RETAINMENT_PRECEDENT')

  =back

  Specific descriptions of how these work are detailed below.

  =over

  =item merge ( <hashref>, <hashref> )

  Merges two hashes given the rules specified.  Returns a reference to
  the new hash.

  =item _hashify( <scalar>|<arrayref> ) -- INTERNAL FUNCTION

  Returns a reference to a hash created from the scalar or array reference,
  where, for the scalar value, or each item in the array, there is a key
  and it's value equal to that specific value.  Example, if you pass scalar
  '3', the hash will be { 3 => 3 }.

  =item _merge_hashes( <hashref>, <hashref> ) -- INTERNAL FUNCTION

  Actually does the key-by-key evaluation of two hashes and returns
  the new merged hash.  Note that this recursively calls C<merge>.

  =item set_clone_behavior( <scalar> )

  Sets how the data cloning is handled by Hash::Merge.  If this is true,
  then data will be cloned; if false, then original data will be used
  whenever possible.  By default, cloning is on (set to true).

  =item get_clone_behavior( )

  Returns the current behavior for data cloning.

  =item set_behavior( <scalar> )

  Specify which built-in behavior for merging that is desired.  The scalar
  must be one of those given below.

  =item get_behavior( )

  Returns the behavior that is currently in use by Hash::Merge.

  =item specify_behavior( <hashref>, [<name>] )

  Specify a custom merge behavior for Hash::Merge.  This must be a hashref
  defined with (at least) 3 keys, SCALAR, ARRAY, and HASH; each of those
  keys must have another hashref with (at least) the same 3 keys defined.
  Furthermore, the values in those hashes must be coderefs.  These will be
  called with two arguments, the left and right values for the merge.
  Your coderef should return either a scalar or an array or hash reference
  as per your planned behavior.  If necessary, use the functions
  _hashify and _merge_hashes as helper functions for these.  For example,
  if you want to add the left SCALAR to the right ARRAY, you can have your
  behavior specification include:

     %spec = ( ...SCALAR => { ARRAY => sub { [ $_[0], @$_[1] ] }, ... } } );

  Note that you can import _hashify and _merge_hashes into your program's
  namespace with the 'custom' tag.

  =back


pkgId: 7d4644fddf3d83dbeb91fe1744ef8e8fe688a872
name: local-perl-Hash-MoreUtils
arch: src
version: 0.01
epoch: 0
release: 1
summary: Hash-MoreUtils - Provide the stuff missing in Hash::Util
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Hans Dieter Pearcey <hdp@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Hash-MoreUtils-0.01-1.src.rpm
checksum_type: sha
description:
  Similar to C<< List::MoreUtils >>, C<< Hash::MoreUtils >>
  contains trivial but commonly-used functionality for hashes.


pkgId: a8fdb0085f6aff362cfdd4dc95bd024002772a9b
name: local-perl-Hash-MultiValue
arch: src
version: 0.12
epoch: 0
release: 1
summary: Hash-MultiValue - Store multiple values per key
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tatsuhiko Miyagawa <miyagawa@bulknews.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Hash-MultiValue-0.12-1.src.rpm
checksum_type: sha
description:
  Hash::MultiValue is an object (and a plain hash reference) that may
  contain multiple values per key, inspired by MultiDict of WebOb.


pkgId: f57b215fd349ab9f73b5e1a46adbf1a85d159626
name: local-perl-Heap
arch: src
version: 0.80
epoch: 0
release: 1
summary: Heap - Perl extensions for keeping data partially sorted
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: John Macdonald <john@perlwolf.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Heap-0.80-1.src.rpm
checksum_type: sha
description:
  The Heap collection of modules provide routines that manage
  a heap of elements.  A heap is a partially sorted structure
  that is always able to easily extract the smallest of the
  elements in the structure (or the largest if a reversed compare
  routine is provided).

  If the collection of elements is changing dynamically, the
  heap has less overhead than keeping the collection fully
  sorted.

  The elements must be objects as described in L<"Heap::Elem">
  and all elements inserted into one heap must be mutually
  compatible - either the same class exactly or else classes that
  differ only in ways unrelated to the B<Heap::Elem> interface.


pkgId: f8bcebc06a76c39c99a037c9e9b4cc325ef73e32
name: local-perl-IO-Compress-Base
arch: src
version: 2.012
epoch: 0
release: 1
summary: IO-Compress-Base - Base Class for IO::Compress modules
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Paul Marquess <pmqs@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Compress-Base-2.012-1.src.rpm
checksum_type: sha
description:
  This module is not intended for direct use in application code. Its sole
  purpose if to to be sub-classed by IO::Compress modules.


pkgId: a8cab38f90421af4fd4b9dbdd114428acae50d21
name: local-perl-IO-Compress-Bzip2
arch: src
version: 2.008
epoch: 0
release: 1
summary: IO-Compress-Bzip2 - Write bzip2 files/buffers
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Paul Marquess <pmqs@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Compress-Bzip2-2.008-1.src.rpm
checksum_type: sha
description:
  This module provides a Perl interface that allows writing bzip2
  compressed data to files or buffer.











  For reading bzip2 files/buffers, see the companion module
  L<IO::Uncompress::Bunzip2|IO::Uncompress::Bunzip2>.


pkgId: 54a14674e9cb191205cfb8e7980729d36c4d9a77
name: local-perl-IO-Interactive
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: IO-Interactive - Utilities for interactive I/O
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Damian Conway <DCONWAY@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Interactive-0.0.6-1.src.rpm
checksum_type: sha
description:
  This module provides three utility subroutines that make it easier to
  develop interactive applications...

  =over

  =item C<is_interactive()>

  This subroutine returns true if C<*ARGV> and the currently selected
  filehandle (usually C<*STDOUT>) are connected to the terminal. The
  test is considerably more sophisticated than:

      -t *ARGV && -t *STDOUT

  as it takes into account the magic behaviour of C<*ARGV>.

  You can also pass C<is_interactive> a writable filehandle, in which case it
  requires that filehandle be connected to a terminal (instead of the
  currently selected).  The usual suspect here is C<*STDERR>:

      if ( is_interactive(*STDERR) ) {
          carp $warning;
      }


  =item C<interactive()>

  This subroutine returns C<*STDOUT> if C<is_interactive> is true. If
  C<is_interactive()> is false, C<interactive> returns a filehandle that
  does not print.

  This makes it easy to create applications that print out only when the
  application is interactive:

      print {interactive} "Please enter a value: ";
      my $value = <>;

  You can also pass C<interactive> a writable filehandle, in which case it
  writes to that filehandle if it is connected to a terminal (instead of
  writinbg to C<*STDOUT>). Once again, the usual suspect is C<*STDERR>:

      print {interactive(*STDERR)} $warning;


  =item C<busy {...}>

  This subroutine takes a block as its single argument and executes that block.
  Whilst the block is executed, C<*ARGV> is temporarily replaced by a closed
  filehandle. That is, no input from C<*ARGV> is possible in a C<busy> block.
  Furthermore, any attempts to send input into the C<busy> block through
  C<*ARGV> is intercepted and a warning message is printed to C<*STDERR>.
  The C<busy> call returns a filehandle that contains the intercepted input.

  A C<busy> block is therefore useful to prevent attempts at input when the
  program is busy at some non-interactive task.

  =back


pkgId: 21a7f3f4fe6220838e1d95f402a2b6a02a45ef08
name: local-perl-IO-Interface
arch: src
version: 1.05
epoch: 0
release: 1
summary: IO-Interface - Perl extension for access to network card configuration information
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Lincoln Stein <Eltlstein@cshl.orgEgt>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Interface-1.05-1.src.rpm
checksum_type: sha
description:
  IO::Interface adds methods to IO::Socket objects that allows them to
  be used to retrieve and change information about the network
  interfaces on your system.  In addition to the object-oriented access
  methods, you can use a function-oriented style.

  THIS API IS DEPRECATED. Please see L<IO::Interface::Simple> for the
  preferred way to get and set interface configuration information.


pkgId: 1966ba7c84895d3e0def08c5892cdf26f58953aa
name: local-perl-IO-LockedFile
arch: src
version: 0.23
epoch: 0
release: 1
summary: IO-LockedFile - supply object methods for locking files
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Rani Pinchuk <rani@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-LockedFile-0.23-1.src.rpm
checksum_type: sha
description:
  In its simplistic use, the B<IO::LockedFile> class gives us the same
  interface of the B<IO::File> class with the unique difference that the
  files we deal with are locked using the B<Flock> mechanism (using the
  C<flock> function).

  If during the running of the process, it crashed - the file will
  be automatically unlocked. Actually - if the B<IO::LockedFile> object goes
  out of scope, the file is automatically closed and unlocked.

  So, if you are just interested in having locked files with C<flock>, you
  can skip most of the documentation below.

  If, on the other hand, you are interested in locking files with other
  schemes then B<Flock>, or you want to control the behavior of the locking
  (having non blocking lock for example), read on.

  Actually the class B<IO::LockedFile> is kind of abstract class.

  Why abstract? Because methods of this class call the methods C<lock>
  and C<unlock>. But those methods are not really implemented in this class.
  They suppose to be implemented in the derived classes of B<IO::LockedFile>.

  Why "kind" of abstract? Because the constructor of this class will return an
  object!

  How abstract class can create objects? This is done by having the constructor
  returning object that is actually an object of one of the derived classes of
  B<IO::LockedFile>.

  So by default the constructor of B<IO::LockedFile> will return an object of
  B<IO::LockedFile::Flock>. For example, the following:

     use IO::LockedFile;
     $lock = new IO::LockedFile(">bla");
     print ref($lock);

  Will give:

     IO::LockedFile::Flock

  So what are the conclusions here?

  First of all - do not be surprised to get object of derived class from the
  constructor of B<IO::LockedFile>.

  Secondly - by changing the default behavior of the constructor of
  B<IO::LockedFile>, we can get object of other class which means that we
  have a locked file that is locked with other scheme.

  The default behavior of the constructor is determined by the global options.

  We can access this global options, or the options per object using the method
  C<set_option> and C<get_option>.

  We can set the global options in the use line:

    use IO::LockedFile 'Flock'; # set the default scheme to be Flock

    use IO::LockedFile ( scheme => Flock );

  We can also set the options of a new object by passing the options to the
  constructor, as we will see below. We can change the options of an existing
  object by using the C<set_option> method.

  Which options are available?

  =over 4

  =item I<scheme>

  The I<scheme> let us define which derived class we use for the object
  we create.
  See below which derived classes are available. The default scheme is 'Flock'.

  =item I<block>

  The I<block> option can be 1 or 0 (true or false). If it is 1, a call to the
  C<open> method or to the constructor will be blocked if the file we try to open
  is already locked. This means that those methods will not return till the
  file is unlocked. If the value of the I<block> option is 0, the C<open> and the
  constructor will return immediately in any case. If the file is locked,
  those methods will return undef. The default value of the I<block> option is
  1.

  =item I<lock>

  The I<lock> option can be 1 or 0 (true or false). It defines if the file we
  open when we create the object will be opened locked. Sometimes, we want
  to have a file that can be locked, yet we do not want to open it locked from
  the beginning. For example if we want to print into a log file, usually we
  want to lock that file only when we print into it. Yet, it might be that
  when we open the file in the beginning we do not print into it immediately.
  In that case we will prefer to open the file as unlocked, and later we will
  lock it when needed. The default value of the I<lock> option is 1.

  =back

  There might be extra options that are used by one of the derived classes. So
  according to the scheme you choose to use, please look in the manual page of
  the class that implement that scheme.

  Finally, some information that is connected to a certain scheme will be found
  in the classes that are derived from this class. For example, compatibility
  issues will be discussed in each derived classes.

  The classes that currently implement the interface that B<IO::LockedFile>
  defines are:

  =over 4

  =item *

  B<IO::LockedFile::Flock>

  =back


pkgId: dcda0a366bf23c40f3575ef361d741c2827e70c4
name: local-perl-IO-Pager
arch: src
version: 0.05
epoch: 0
release: 1
summary: IO-Pager - Select a pager, optionally pipe it output if destination is a TTY
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Jerrad Pierce <belg4mit@mit.edu>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Pager-0.05-1.src.rpm
checksum_type: sha
description:
  IO::Pager is lightweight and can be used to locate an available pager
  and set $ENV{PAGER} (see L</NOTES>) or as a factory for creating objects
  defined elsewhere such as L<IO::Pager::Buffered> and L<IO::Pager::Unbuffered>.

  IO::Pager subclasses are designed to programmatically decide whether
  or not to pipe a filehandle's output to a program specified in $ENV{PAGER}.
  Subclasses are only required to support filehandle output methods and close,
  namely

  =over

  =item CLOSE

  Supports close() of the filehandle.

  =item PRINT

  Supports print() to the filehandle.

  =item PRINTF

  Supports printf() to the filehandle.

  =item WRITE

  Supports syswrite() to the filehandle.

  =back

  For anything else, YMMV.


pkgId: 9c74759f38b8432680fd3cfd3b7b1fea7967f8d7
name: local-perl-IO-Socket-Multicast
arch: src
version: 1.05
epoch: 0
release: 1
summary: IO-Socket-Multicast - Send and receive multicast messages
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Lincoln Stein <lstein@cshl.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Socket-Multicast-1.05-1.src.rpm
checksum_type: sha
description:
  The IO::Socket::Multicast module subclasses IO::Socket::INET to enable
  you to manipulate multicast groups.  With this module (and an
  operating system that supports multicasting), you will be able to
  receive incoming multicast transmissions and generate your own
  outgoing multicast packets.

  This module requires IO::Interface version 0.94 or higher.


pkgId: 3629ca8544296fcb9c6247139cc25f810ada2a31
name: local-perl-IO-Socket-SSL
arch: src
version: 1.14
epoch: 0
release: 1
summary: IO-Socket-SSL - Nearly transparent SSL encapsulation for IO::Socket::INET.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Steffen Ullrich & Peter Behroozi & Marko Asplund
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Socket-SSL-1.14-1.src.rpm
checksum_type: sha
description:
  This module is a true drop-in replacement for IO::Socket::INET that uses
  SSL to encrypt data before it is transferred to a remote server or
  client.	 IO::Socket::SSL supports all the extra features that one needs
  to write a full-featured SSL client or server application: multiple SSL contexts,
  cipher selection, certificate verification, and SSL version selection.	As an
  extra bonus, it works perfectly with mod_perl.

  If you have never used SSL before, you should read the appendix labelled 'Using SSL'
  before attempting to use this module.

  If you have used this module before, read on, as versions 0.93 and above
  have several changes from the previous IO::Socket::SSL versions (especially
  see the note about return values).

  If you are using non-blocking sockets read on, as version 0.98 added better
  support for non-blocking.

  If you are trying to use it with threads see the BUGS section.


pkgId: cea45b48ed9c9ee90dd7d46912d6c1741fb55ffe
name: local-perl-IO-String
arch: src
version: 1.08
epoch: 0
release: 1
summary: IO-String - Emulate file interface for in-core strings
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: gaas@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-String-1.08-1.src.rpm
checksum_type: sha
description:
  The C<IO::String> module provides the C<IO::File> interface for in-core
  strings.  An C<IO::String> object can be attached to a string, and
  makes it possible to use the normal file operations for reading or
  writing data, as well as for seeking to various locations of the string.
  This is useful when you want to use a library module that only
  provides an interface to file handles on data that you have in a string
  variable.

  Note that perl-5.8 and better has built-in support for "in memory"
  files, which are set up by passing a reference instead of a filename
  to the open() call. The reason for using this module is that it
  makes the code backwards compatible with older versions of Perl.

  The C<IO::String> module provides an interface compatible with
  C<IO::File> as distributed with F<IO-1.20>, but the following methods
  are not available: new_from_fd, fdopen, format_write,
  format_page_number, format_lines_per_page, format_lines_left,
  format_name, format_top_name.

  The following methods are specific to the C<IO::String> class:

  =over 4

  =item $io = IO::String->new

  =item $io = IO::String->new( $string )

  The constructor returns a newly-created C<IO::String> object.  It
  takes an optional argument, which is the string to read from or write
  into.  If no $string argument is given, then an internal buffer
  (initially empty) is allocated.

  The C<IO::String> object returned is tied to itself.  This means
  that you can use most Perl I/O built-ins on it too: readline, <>, getc,
  print, printf, syswrite, sysread, close.

  =item $io->open

  =item $io->open( $string )

  Attaches an existing IO::String object to some other $string, or
  allocates a new internal buffer (if no argument is given).  The
  position is reset to 0.

  =item $io->string_ref

  Returns a reference to the string that is attached to
  the C<IO::String> object.  Most useful when you let the C<IO::String>
  create an internal buffer to write into.

  =item $io->pad

  =item $io->pad( $char )

  Specifies the padding to use if
  the string is extended by either the seek() or truncate() methods.  It
  is a single character and defaults to "\0".

  =item $io->pos

  =item $io->pos( $newpos )

  Yet another interface for reading and setting the current read/write
  position within the string (the normal getpos/setpos/tell/seek
  methods are also available).  The pos() method always returns the
  old position, and if you pass it an argument it sets the new
  position.

  There is (deliberately) a difference between the setpos() and seek()
  methods in that seek() extends the string (with the specified
  padding) if you go to a location past the end, whereas setpos()
  just snaps back to the end.  If truncate() is used to extend the string,
  then it works as seek().

  =back


pkgId: 1a047d7cf3bd057fff0c1665fdd8efa64bfe2fe6
name: local-perl-IO-Tty
arch: src
version: 1.07
epoch: 0
release: 1
summary: IO-Tty - Pseudo ttys and constants
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Roland Giersig <RGiersig@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Tty-1.07-1.src.rpm
checksum_type: sha
description:
  C<IO::Tty> is used internally by C<IO::Pty> to create a pseudo-tty.
  You wouldn't want to use it directly except to import constants, use
  C<IO::Pty>.  For a list of importable constants, see
  L<IO::Tty::Constant>.

  Windows is now supported, but ONLY under the Cygwin
  environment, see L<http://sources.redhat.com/cygwin/>.

  Please note that pty creation is very system-dependend.  From my
  experience, any modern POSIX system should be fine.  Find below a list
  of systems that C<IO::Tty> should work on.  A more detailed table
  (which is slowly getting out-of-date) is available from the project
  pages document manager at SourceForge
  L<http://sourceforge.net/projects/expectperl/>.

  If you have problems on your system and your system is listed in the
  "verified" list, you probably have some non-standard setup, e.g. you
  compiled your Linux-kernel yourself and disabled ptys (bummer!).
  Please ask your friendly sysadmin for help.

  If your system is not listed, unpack the latest version of C<IO::Tty>,
  do a C<'perl Makefile.PL; make; make test; uname -a'> and send me
  (F<RGiersig@cpan.org>) the results and I'll see what I can deduce from
  that.  There are chances that it will work right out-of-the-box...

  If it's working on your system, please send me a short note with
  details (version number, distribution, etc. 'uname -a' and 'perl -V'
  is a good start; also, the output from "perl Makefile.PL" contains a
  lot of interesting info, so please include that as well) so I can get
  an overview.  Thanks!


pkgId: 251b02fcd093bdf7a03965a1b2a139af0dd6ebda
name: local-perl-IO-Zlib
arch: src
version: 1.09
epoch: 0
release: 1
summary: IO-Zlib - IO:: style interface to Compress::Zlib
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: tomhughes@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-Zlib-1.09-1.src.rpm
checksum_type: sha
description:
  "IO::Zlib" provides an IO:: style interface to Compress::Zlib and
  hence to gzip/zlib compressed files. It provides many of the same methods
  as the IO::Handle interface.

  Starting from IO::Zlib version 1.02, IO::Zlib can also use an
  external gzip command.  The default behaviour is to try to use
  an external gzip if no "Compress::Zlib" can be loaded, unless
  explicitly disabled by

      use IO::Zlib qw(:gzip_external 0);

  If explicitly enabled by

      use IO::Zlib qw(:gzip_external 1);

  then the external gzip is used instead of "Compress::Zlib".


pkgId: 9a65331010aacadd829dee900142563ff538f488
name: local-perl-IO-stringy
arch: src
version: 2.110
epoch: 0
release: 1
summary: IO-stringy - stringy - I/O on in-core objects like strings and arrays
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: <>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IO-stringy-2.110-1.src.rpm
checksum_type: sha
description:
  This toolkit primarily provides modules for performing both traditional
  and object-oriented i/o) on things I<other> than normal filehandles;
  in particular, L<IO::Scalar|IO::Scalar>, L<IO::ScalarArray|IO::ScalarArray>,
  and L<IO::Lines|IO::Lines>.

  In the more-traditional IO::Handle front, we
  have L<IO::AtomicFile|IO::AtomicFile>
  which may be used to painlessly create files which are updated
  atomically.

  And in the "this-may-prove-useful" corner, we have L<IO::Wrap|IO::Wrap>,
  whose exported wraphandle() function will clothe anything that's not
  a blessed object in an IO::Handle-like wrapper... so you can just
  use OO syntax and stop worrying about whether your function's caller
  handed you a string, a globref, or a FileHandle.


pkgId: 5ddc5eed324e8387773e7940a3c3d0151da9fe68
name: local-perl-IPC-Cmd
arch: src
version: 0.72
epoch: 0
release: 1
summary: IPC-Cmd - A cross platform way of running (interactive) commandline programs.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Jos Boumans <kane[at]cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IPC-Cmd-0.72-1.src.rpm
checksum_type: sha
description:
  IPC::Cmd allows you to run commands platform independently,
  interactively if desired, but have them still work.

  The C<can_run> function can tell you if a certain binary is installed
  and if so where, whereas the C<run> function can actually execute any
  of the commands you give it and give you a clear return value, as well
  as adhere to your verbosity settings.


pkgId: da8fcef5a5ae8b7a4750cbe55fff9236b220a091
name: local-perl-IPC-Run
arch: src
version: 0.80
epoch: 0
release: 1
summary: IPC-Run - system() and background procs w/ piping, redirs, ptys (Unix, Win32)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Barrie Slaymaker <barries@slaysys.com,>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IPC-Run-0.80-1.src.rpm
checksum_type: sha
description:
  IPC::Run allows you run and interact with child processes using files, pipes,
  and pseudo-ttys.  Both system()-style and scripted usages are supported and
  may be mixed.  Likewise, functional and OO API styles are both supported and
  may be mixed.

  Various redirection operators reminiscent of those seen on common Unix and DOS
  command lines are provided.

  Before digging in to the details a few LIMITATIONS are important enough
  to be mentioned right up front:

  =over

  =item Win32 Support

  Win32 support is working but B<EXPERIMENTAL>, but does pass all relevant tests
  on NT 4.0.  See L</Win32 LIMITATIONS>.

  =item pty Support

  If you need pty support, IPC::Run should work well enough most of the
  time, but IO::Pty is being improved, and IPC::Run will be improved to
  use IO::Pty's new features when it is release.

  The basic problem is that the pty needs to initialize itself before the
  parent writes to the master pty, or the data written gets lost.  So
  IPC::Run does a sleep(1) in the parent after forking to (hopefully) give
  the child a chance to run.  This is a kludge that works well on non
  heavily loaded systems :(.

  ptys are not supported yet under Win32, but will be emulated...

  =item Debugging Tip

  You may use the environment variable C<IPCRUNDEBUG> to see what's going on
  under the hood:

     $ IPCRUNDEBUG=basic   myscript     # prints minimal debugging
     $ IPCRUNDEBUG=data    myscript     # prints all data reads/writes
     $ IPCRUNDEBUG=details myscript     # prints lots of low-level details
     $ IPCRUNDEBUG=gory    myscript     # (Win32 only) prints data moving through
                                        

  =back

  We now return you to your regularly scheduled documentation.


pkgId: 593a9f978cdf383894928bb1c92a71f5b47b3b2e
name: local-perl-IPC-Run3
arch: src
version: 0.042
epoch: 0
release: 1
summary: IPC-Run3 - run a subprocess with input/ouput redirection
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Barrie Slaymaker <barries@slaysys.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IPC-Run3-0.042-1.src.rpm
checksum_type: sha
description:
  This module allows you to run a subprocess and redirect stdin, stdout,
  and/or stderr to files and perl data structures.  It aims to satisfy 99% of the
  need for using C<system>, C<qx>, and C<open3>
  with a simple, extremely Perlish API.

  Speed, simplicity, and portability are paramount.  (That's speed of Perl code;
  which is often much slower than the kind of buffered I/O that this module uses
  to spool input to and output from the child command.)


pkgId: 8bdaa481e0fda40d79b37611006c82eabb3a866f
name: local-perl-IPC-ShareLite
arch: src
version: 0.13
epoch: 0
release: 1
summary: IPC-ShareLite - Lightweight interface to shared memory
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Maurice Aubrey <maurice@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IPC-ShareLite-0.13-1.src.rpm
checksum_type: sha
description:
  IPC::ShareLite provides a simple interface to shared memory, allowing
  data to be efficiently communicated between processes. Your operating
  system must support SysV IPC (shared memory and semaphores) in order to
  use this module.

  IPC::ShareLite provides an abstraction of the shared memory and
  semaphore facilities of SysV IPC, allowing the storage of arbitrarily
  large data; the module automatically acquires and removes shared memory
  segments as needed. Storage and retrieval of data is atomic, and locking
  functions are provided for higher-level synchronization.

  In many respects, this module is similar to IPC::Shareable. However,
  IPC::ShareLite does not provide a tied interface, does not
  (automatically) allow the storage of variables, and is written in C
  for additional speed.

  Construct an IPC::ShareLite object by calling its constructor:

      my $share = IPC::ShareLite->new(
          -key     => 1971,
          -create  => 'yes',
          -destroy => 'no'
      ) or die $!;

  Once an instance has been created, data can be written to shared memory
  by calling the store() method:

  	$share->store("This is going in shared memory");

  Retrieve the data by calling the fetch() method:

  	my $str = $share->fetch();

  The store() and fetch() methods are atomic; any processes attempting
  to read or write to the memory are blocked until these calls finish.
  However, in certain situations, you'll want to perform multiple
  operations atomically.  Advisory locking methods are available for
  this purpose.

  An exclusive lock is obtained by calling the lock() method:

  	$share->lock();

  Happily, the lock() method also accepts all of the flags recognized
  by the flock() system call.  So, for example, you can obtain a
  shared lock like this:

  	$share->lock( LOCK_SH );

  Or, you can make either type of lock non-blocking:

  	$share->lock( LOCK_EX|LOCK_NB );

  Release the lock by calling the unlock() method:

  	$share->unlock;


pkgId: ed5e5f41f3a9b9fb6b93156b62e1c14861a42143
name: local-perl-IPC-Shareable
arch: src
version: 0.6
epoch: 0
release: 1
summary: IPC-Shareable - share Perl variables between processes
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Benjamin Sugars <bsugars@canoe.ca>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-IPC-Shareable-0.6-1.src.rpm
checksum_type: sha
description:
  IPC::Shareable allows you to tie a variable to shared memory making it
  easy to share the contents of that variable with other Perl processes.
  Scalars, arrays, and hashes can be tied.  The variable being tied may
  contain arbitrarily complex data structures - including references to
  arrays, hashes of hashes, etc.

  The association between variables in distinct processes is provided by
  GLUE.  This is an integer number or 4 character string[1] that serves
  as a common identifier for data across process space.  Hence the
  statement

   tie $scalar, 'IPC::Shareable', 'data';

  in program one and the statement

   tie $variable, 'IPC::Shareable', 'data';

  in program two will bind $scalar in program one and $variable in
  program two.

  There is no pre-set limit to the number of processes that can bind to
  data; nor is there a pre-set limit to the complexity of the underlying
  data of the tied variables[2].  The amount of data that can be shared
  within a single bound variable is limited by the system's maximum size
  for a shared memory segment (the exact value is system-dependent).

  The bound data structures are all linearized (using Raphael Manfredi's
  Storable module) before being slurped into shared memory.  Upon
  retrieval, the original format of the data structure is recovered.
  Semaphore flags can be used for locking data between competing processes.


pkgId: 8adfcecbf2599ef37a149dacfbf1bd1eca731852
name: local-perl-Internals
arch: src
version: 1.1
epoch: 0
release: 1
summary: Internals - Write-protect variables, manipulate refcounts
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Steffen Beyer <mailto:sb@engelschall.com>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Internals-1.1-1.src.rpm
checksum_type: sha
description:
  This module allows you to write-protect and write-enable
  your Perl variables, objects and data structures.

  Moreover, the reference count of any Perl variable can
  be read and set.

  You can never pass the object directly on which to
  perform the desired action, you always have to pass
  a reference to the variable or data structure in
  question.

  This comes in handy for objects and anonymous data
  structures, where you only have a reference anyway!

  BEWARE: This module is DANGEROUS!

  DO NOT attempt to unlock Perl's built-in variables!

  DO NOT manipulate reference counts unless you know
  exactly what you're doing!

  ANYTHING might happen! Hell might break loose! C<:-)>

  YOU HAVE BEEN WARNED!


pkgId: 481b190d04d025f567a4804d0e8de9ade3dac477
name: local-perl-JSON
arch: src
version: 1.15
epoch: 0
release: 1
summary: JSON - parse and convert to JSON (JavaScript Object Notation).
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-JSON-1.15-1.src.rpm
checksum_type: sha
description:
  This module converts between JSON (JavaScript Object Notation) and Perl
  data structure into each other.
  For JSON, See to http://www.crockford.com/JSON/.


pkgId: 8732d08351725bfc74dfda170c03f9343841e219
name: local-perl-JSON
arch: src
version: 2.12
epoch: 0
release: 1
summary: JSON - JSON (JavaScript Object Notation) encoder/decoder
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-JSON-2.12-1.src.rpm
checksum_type: sha
description:
  ************************** CAUTION ********************************
   * This is 'JSON module version 2' and there are many differences  *
   * to version 1.xx                                                 *
   * Please check your applications useing old version.              *
   *   See to 'INCOMPATIBLE CHANGES TO OLD VERSION'                  *
   *******************************************************************

  JSON (JavaScript Object Notation) is a simple data format.
  See to L<http://www.json.org/> and C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>).

  This module converts Perl data structures to JSON and vice versa using either
  L<JSON::XS> or L<JSON::PP>.

  JSON::XS is the fastest and most proper JSON module on CPAN which must be
  compiled and installed in your environment.
  JSON::PP is a pure-Perl module which is bundled in this distribution and
  has a strong compatibility to JSON::XS.

  This module try to use JSON::XS by default and fail to it, use JSON::PP instead.
  So its features completely depend on JSON::XS or JSON::PP.

  See to L<BACKEND MODULE DECISION>.

  To distinguish the module name 'JSON' and the format type JSON,
  the former is quoted by CE<lt>E<gt> (its results vary with your using media),
  and the latter is left just as it is.

  Module name : C<JSON>

  Format type : JSON


pkgId: c476be6903d9eb3c74b1652b9596a1be220a740e
name: local-perl-JSON-Any
arch: src
version: 1.30
epoch: 0
release: 1
summary: JSON-Any - Wrapper Class for the various JSON classes.
description: None.
url: http://www.cpan.org
rpm_license: Artistic
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-JSON-Any-1.30-1.src.rpm
checksum_type: sha
rpm_vendor:
  Chris Thompson <cthom@cpan.org>, Chris Prather <chris@prather.org>, Robin Berjon <robin@berjon.com>, Marc Mims <marc@questright.com>, Tomas Doran <bobtfish@bobtfish.net>


pkgId: a9c0789f94f325cc0db6e28da2235e5c8ee5c4dd
name: local-perl-JSON-PP
arch: src
version: 2.27200
epoch: 0
release: 1
summary: JSON-PP - JSON::XS compatible pure-Perl module.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-JSON-PP-2.27200-1.src.rpm
checksum_type: sha
description:
  This module is L<JSON::XS> compatible pure Perl module.
  (Perl 5.8 or later is recommended)

  JSON::XS is the fastest and most proper JSON module on CPAN.
  It is written by Marc Lehmann in C, so must be compiled and
  installed in the used environment.

  JSON::PP is a pure-Perl module and has compatibility to JSON::XS.


pkgId: 21ea6e49230e85da8793223c699d8a522d9af57f
name: local-perl-JSON-XS
arch: src
version: 2.25
epoch: 0
release: 1
summary: JSON-XS - JSON serialising/deserialising, done correctly and fast
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Marc Lehmann <schmorp@schmorp.de>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-JSON-XS-2.25-1.src.rpm
checksum_type: sha
description:
  This module converts Perl data structures to JSON and vice versa. Its
  primary goal is to be I<correct> and its secondary goal is to be
  I<fast>. To reach the latter goal it was written in C.

  Beginning with version 2.0 of the JSON module, when both JSON and
  JSON::XS are installed, then JSON will fall back on JSON::XS (this can be
  overridden) with no overhead due to emulation (by inheriting constructor
  and methods). If JSON::XS is not available, it will fall back to the
  compatible JSON::PP module as backend, so using JSON instead of JSON::XS
  gives you a portable JSON API that can be fast when you need and doesn't
  require a C compiler when that is a problem.

  As this is the n-th-something JSON module on CPAN, what was the reason
  to write yet another JSON module? While it seems there are many JSON
  modules, none of them correctly handle all corner cases, and in most cases
  their maintainers are unresponsive, gone missing, or not listening to bug
  reports for other reasons.

  See MAPPING, below, on how JSON::XS maps perl values to JSON values and
  vice versa.


pkgId: 33a0c1c17bdb94a3f74943672f104a3827586154
name: local-perl-Jcode
arch: src
version: 2.07
epoch: 0
release: 1
summary: Jcode - Japanese Charset Handler
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Dan Kogai <dankogai@dan.co.jp>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Jcode-2.07-1.src.rpm
checksum_type: sha
description:
  B<<Japanese document is now available as L<Jcode::Nihongo>. >>

  Jcode.pm supports both object and traditional approach.
  With object approach, you can go like;

    $iso_2022_jp = Jcode->new($str)->h2z->jis;

  Which is more elegant than:

    $iso_2022_jp = $str;
    &jcode::convert(\$iso_2022_jp, 'jis', &jcode::getcode(\$str), "z");

  For those unfamiliar with objects, Jcode.pm still supports C<getcode()>
  and C<convert().>

  If the perl version is 5.8.1, Jcode acts as a wrapper to L<Encode>,
  the standard charset handler module for Perl 5.8 or later.


pkgId: 8ce996f2602cfcf6cc7df57dc33a3e996f146e50
name: local-perl-LWES
arch: src
version: 0.01
epoch: 0
release: 1
summary: LWES - Perl extension for the Light Weight Event System
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Anthony Molinaro <Eltmolinaro@users.sourceforge.netEgt>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-LWES-0.01-1.src.rpm
checksum_type: sha
description:
  This is the Perl interface to the Light Weight Event System.  The
  Light Weight Event System is a UDP-based communication toolkit with
  built-in serialization, formatting, and type-checking.


pkgId: 448a4b420d14959d5be8fe7316b2fca648d47ee6
name: local-perl-Lingua-EN-Inflect-Number
arch: src
version: 1.1
epoch: 0
release: 1
summary: Lingua-EN-Inflect-Number - Force number of words to singular or plural
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Simon Cozens <Csimon@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Lingua-EN-Inflect-Number-1.1-1.src.rpm
checksum_type: sha
description:
  This module extends the functionality of Lingua::EN::Inflect with three
  new functions available for export:


pkgId: 391b5854e15a4db8f60cfb03419282e2fec79333
name: local-perl-Lingua-EN-Numbers
arch: src
version: 1.01
epoch: 0
release: 1
summary: Lingua-EN-Numbers - turn "407" into "four hundred and seven", etc.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Sean M Burke <sburke@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Lingua-EN-Numbers-1.01-1.src.rpm
checksum_type: sha
description:
  Lingua::EN::Numbers turns numbers into English text.  It exports
  (upon request) two functions,
  C<num2en> and C<num2en_ordinal>.  Each takes a scalar value and returns
  a scalar value.  The return value is the English text expressing that
  number; or if what you provided wasn't a number, then they return undef.

  This module can handle integers like "12" or "-3" and real numbers like "53.19".

  This module also understands exponential notation -- it turns "4E9" into
  "four times ten to the ninth").  And it even turns "INF", "-INF", "NaN"
  into "infinity", "negative infinity", and "not a number", respectively.

  Any commas in the input numbers are ignored.


pkgId: 17fa8f6884501f517245319f411dc50ad7eaeeaf
name: local-perl-Lingua-Ispell
arch: src
version: 0.07
epoch: 0
release: 1
summary: Lingua-Ispell - a module encapsulating access to the Ispell program.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: <jdporter@min.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Lingua-Ispell-0.07-1.src.rpm
checksum_type: sha
description:
  Lingua::Ispell::spellcheck() takes one argument.  It must be a
  string, and it should contain only printable characters.
  One allowable exception is a terminal newline, which will be
  chomped off anyway.  The line is fed to a coprocess running
  ispell for analysis.  ispell parses the line into "terms"
  according to the language-specific rules in effect.

  The result of ispell's analysis of each term is a categorization
  of the term into one of six types: ok, compound, root, miss, none,
  and guess.  Some of these carry additional information.
  The first three types are "correctly" spelled terms, and the last
  three are for "incorrectly" spelled terms.

  Lingua::Ispell::spellcheck returns a list of objects, each
  corresponding to a term in the spellchecked string.  Each object
  is a hash (hash-ref) with at least two entries: 'term' and 'type'.
  The former contains the term ispell is reporting on, and the latter
  is ispell's determination of that term's type (see above).
  For types 'ok' and 'none', that is all the information there is.
  For the type 'root', an additional hash entry is present: 'root'.
  Its value is the word which ispell identified in the dictionary
  as being the likely root of the current term.
  For the type 'miss', an additional hash entry is present: 'misses'.
  Its value is an ref to an array of words which ispell
  identified as being "near-misses" of the current term, when
  scanning the dictionary.


pkgId: 9a767fc639f7023cb46f2481fcb3c8b77b8442aa
name: local-perl-Lingua-PT-Stemmer
arch: src
version: 0.01
epoch: 0
release: 1
summary: Lingua-PT-Stemmer - Portuguese language stemming
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: xern <xern@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Lingua-PT-Stemmer-0.01-1.src.rpm
checksum_type: sha
description:
  This module implements a Portuguese stemming algorithm proposed in the paper B<A Stemming Algorithm for the Portuguese Language> by B<Moreira, V.> and B<Huyck, C.>

  The eight steps of stemming algorithm are listed as follows:

  =over 8

  =item * Plural Reduction

  =item * Feminine Reduction

  =item * Adverb Reduction

  =item * Augmentative/Diminutive Reduction

  =item * Noun Suffix Reduction

  =item * Verb Suffix Reduction

  =item * Vowel Reduction

  =item * Accents Removal

  =back


pkgId: 42abe2b0b653aed3516a358fbf5c9e5760e9b73d
name: local-perl-Lingua-Stem-Fr
arch: src
version: 0.02
epoch: 0
release: 1
summary: Lingua-Stem-Fr - Perl French Stemming
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Sbastien DarriberePleyt <Eltsebastien.darribere@lefute.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Lingua-Stem-Fr-0.02-1.src.rpm
checksum_type: sha
description:
  This module use the a modified version of the Porter Stemming Algorithm to return a stemmed words.

  The algorithm is implemented as described in:

  http://snowball.tartarus.org/french/stemmer.html

  with some improvement.

  The code is carefully crafted to work in conjunction with the L<Lingua::Stem>
  module by Benjamin Franz.
  This french version is based too, on the work of Aldo Calpini (Italian Version)


pkgId: b98c4a8eaec4084d8e2d2b65c82c8bbec1202fc8
name: local-perl-Lingua-Stem-It
arch: src
version: 0.02
epoch: 0
release: 1
summary: Lingua-Stem-It - Porter's stemming algorithm for Italian
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Aldo Calpini <dada@perl.it>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Lingua-Stem-It-0.02-1.src.rpm
checksum_type: sha
description:
  This module applies the Porter Stemming Algorithm to its parameters,
  returning the stemmed words.

  The algorithm is implemented exactly (I hope :-) as described in:

      http://snowball.tartarus.org/algorithms/italian/stemmer.html

  The code is carefully crafted to work in conjunction with the L<Lingua::Stem>
  module by Benjamin Franz, from which I've also borrowed some functionalities
  (caching and exception list).


pkgId: bcdd4a43ce0ce5abfb6dc6f15175d1bc96cde8fe
name: local-perl-Lingua-Stem-Ru
arch: src
version: 0.01
epoch: 0
release: 1
summary: Lingua-Stem-Ru - Porter's stemming algorithm for Russian
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Aleksandr Guidrevitch <pillgrim@mail.ru>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Lingua-Stem-Ru-0.01-1.src.rpm
checksum_type: sha
description:
  This module applies the Porter Stemming Algorithm to its parameters,
  returning the stemmed words.

  The algorithm is implemented exactly as described in:

      http://snowball.tartarus.org/russian/stemmer.html

  The code is carefully crafted to work in conjunction with the L<Lingua::Stem>
  module by Benjamin Franz. This stemmer is also based
  on the work of Aldo Capini, see L<Lingua::Stem::It>.


pkgId: f4e18784b0749033c64f29bfd6a650f6d0a2e944
name: local-perl-Lingua-Stem-Snowball-Da
arch: src
version: 1.01
epoch: 0
release: 1
summary: Lingua-Stem-Snowball-Da - Porters stemming algorithm for Denmark
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Dennis Haney <davh@davh.dk>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Lingua-Stem-Snowball-Da-1.01-1.src.rpm
checksum_type: sha
description:
  The stem function takes a scalar as a parameter and stems the word
  according to Martin Porters Danish stemming algorithm,
  which can be found at the Snowball website: L<http://snowball.tartarus.org/>.

  It also supports caching if you pass the use_cache option when constructing
  a new L:S:S:D object.


pkgId: e3398a9324c40da03bd619be31f800d5ae390038
name: local-perl-List-MoreUtils
arch: src
version: 0.22
epoch: 0
release: 1
summary: List-MoreUtils - Provide the stuff missing in List::Util
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tassilo von Parseval <tassilo.von.parseval@rwth-aachen.de>
rpm_group: Applications/CPAN
rpm_buildhost: sl4-rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-List-MoreUtils-0.22-1.src.rpm
checksum_type: sha
description:
  C<List::MoreUtils> provides some trivial but commonly needed functionality on lists
  which is not going to go into C<List::Util>.

  All of the below functions are implementable in only a couple of lines of Perl
  code. Using the functions from this module however should give slightly better
  performance as everything is implemented in C. The pure-Perl implementation of
  these functions only serves as a fallback in case the C portions of this module
  couldn't be compiled on this machine.

  =over 4

  =item any BLOCK LIST

  Returns a true value if any item in LIST meets the criterion given through
  BLOCK. Sets C<$_> for each item in LIST in turn:

      print "At least one value undefined"
          if any { !defined($_) } @list;

  Returns false otherwise, or C<undef> if LIST is empty.

  =item all BLOCK LIST

  Returns a true value if all items in LIST meet the criterion given through
  BLOCK. Sets C<$_> for each item in LIST in turn:

      print "All items defined"
          if all { defined($_) } @list;

  Returns false otherwise, or C<undef> if LIST is empty.

  =item none BLOCK LIST

  Logically the negation of C<any>. Returns a true value if no item in LIST meets the
  criterion given through BLOCK. Sets C<$_> for each item in LIST in turn:

      print "No value defined"
          if none { defined($_) } @list;

  Returns false otherwise, or C<undef> if LIST is empty.

  =item notall BLOCK LIST

  Logically the negation of C<all>. Returns a true value if not all items in LIST meet
  the criterion given through BLOCK. Sets C<$_> for each item in LIST in turn:

      print "Not all values defined"
          if notall { defined($_) } @list;

  Returns false otherwise, or C<undef> if LIST is empty.

  =item true BLOCK LIST

  Counts the number of elements in LIST for which the criterion in BLOCK is true. Sets C<$_> for
  each item in LIST in turn:

      printf "%i item(s) are defined", true { defined($_) } @list;

  =item false BLOCK LIST

  Counts the number of elements in LIST for which the criterion in BLOCK is false. Sets C<$_> for
  each item in LIST in turn:

      printf "%i item(s) are not defined", false { defined($_) } @list;

  =item firstidx BLOCK LIST

  =item first_index BLOCK LIST

  Returns the index of the first element in LIST for which the criterion in BLOCK is true. Sets C<$_>
  for each item in LIST in turn:

      my @list = (1, 4, 3, 2, 4, 6);
      printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
      __END__
      item with index 1 in list is 4

  Returns C<-1> if no such item could be found.

  C<first_index> is an alias for C<firstidx>.

  =item lastidx BLOCK LIST

  =item last_index BLOCK LIST

  Returns the index of the last element in LIST for which the criterion in BLOCK is true. Sets C<$_>
  for each item in LIST in turn:

      my @list = (1, 4, 3, 2, 4, 6);
      printf "item with index %i in list is 4", lastidx { $_ == 4 } @list;
      __END__
      item with index 4 in list is 4

  Returns C<-1> if no such item could be found.

  C<last_index> is an alias for C<lastidx>.

  =item insert_after BLOCK VALUE LIST

  Inserts VALUE after the first item in LIST for which the criterion in BLOCK is true. Sets C<$_> for
  each item in LIST in turn.

      my @list = qw/This is a list/;
      insert_after { $_ eq "a" } "longer" => @list;
      print "@list";
      __END__
      This is a longer list

  =item insert_after_string STRING VALUE LIST

  Inserts VALUE after the first item in LIST which is equal to STRING.

      my @list = qw/This is a list/;
      insert_after_string "a", "longer" => @list;
      print "@list";
      __END__
      This is a longer list

  =item apply BLOCK LIST

  Applies BLOCK to each item in LIST and returns a list of the values after BLOCK
  has been applied. In scalar context, the last element is returned.  This
  function is similar to C<map> but will not modify the elements of the input
  list:

      my @list = (1 .. 4);
      my @mult = apply { $_ *= 2 } @list;
      print "\@list = @list\n";
      print "\@mult = @mult\n";
      __END__
      @list = 1 2 3 4
      @mult = 2 4 6 8

  Think of it as syntactic sugar for

      for (my @mult = @list) { $_ *= 2 }

  =item after BLOCK LIST

  Returns a list of the values of LIST after (and not including) the point
  where BLOCK returns a true value. Sets C<$_> for each element in LIST in turn.

      @x = after { $_ % 5 == 0 } (1..9);    # returns 6, 7, 8, 9

  =item after_incl BLOCK LIST

  Same as C<after> but also inclues the element for which BLOCK is true.

  =item before BLOCK LIST

  Returns a list of values of LIST upto (and not including) the point where BLOCK
  returns a true value. Sets C<$_> for each element in LIST in turn.

  =item before_incl BLOCK LIST

  Same as C<before> but also includes the element for which BLOCK is true.

  =item indexes BLOCK LIST

  Evaluates BLOCK for each element in LIST (assigned to C<$_>) and returns a list
  of the indices of those elements for which BLOCK returned a true value. This is
  just like C<grep> only that it returns indices instead of values:

      @x = indexes { $_ % 2 == 0 } (1..10);   # returns 1, 3, 5, 7, 9

  =item firstval BLOCK LIST

  =item first_value BLOCK LIST

  Returns the first element in LIST for which BLOCK evaluates to true. Each
  element of LIST is set to C<$_> in turn. Returns C<undef> if no such element
  has been found.

  C<first_val> is an alias for C<firstval>.

  =item lastval BLOCK LIST

  =item last_value BLOCK LIST

  Returns the last value in LIST for which BLOCK evaluates to true. Each element
  of LIST is set to C<$_> in turn. Returns C<undef> if no such element has been
  found.

  C<last_val> is an alias for C<lastval>.

  =item pairwise BLOCK ARRAY1 ARRAY2

  Evaluates BLOCK for each pair of elements in ARRAY1 and ARRAY2 and returns a
  new list consisting of BLOCK's return values. The two elements are set to C<$a>
  and C<$b>.  Note that those two are aliases to the original value so changing
  them will modify the input arrays.

      @a = (1 .. 5);
      @b = (11 .. 15);
      @x = pairwise { $a + $b } @a, @b;	# returns 12, 14, 16, 18, 20

      
      @a = qw/a b c/;
      @b = qw/1 2 3/;
      @x = pairwise { ($a, $b) } @a, @b;	# returns a, 1, b, 2, c, 3

  =item each_array ARRAY1 ARRAY2 ...

  Creates an array iterator to return the elements of the list of arrays ARRAY1,
  ARRAY2 throughout ARRAYn in turn.  That is, the first time it is called, it
  returns the first element of each array.  The next time, it returns the second
  elements.  And so on, until all elements are exhausted.

  This is useful for looping over more than one array at once:

      my $ea = each_array(@a, @b, @c);
      while ( my ($a, $b, $c) = $ea->() )   { .... }

  The iterator returns the empty list when it reached the end of all arrays.

  If the iterator is passed an argument of 'C<index>', then it retuns
  the index of the last fetched set of values, as a scalar.

  =item each_arrayref LIST

  Like each_array, but the arguments are references to arrays, not the
  plain arrays.

  =item natatime BLOCK LIST

  Creates an array iterator, for looping over an array in chunks of
  C<$n> items at a time.  (n at a time, get it?).  An example is
  probably a better explanation than I could give in words.

  Example:

      my @x = ('a' .. 'g');
      my $it = natatime 3, @x;
      while (my @vals = $it->())
      {
          print "@vals\n";
      }

  This prints

      a b c
      d e f
      g

  =item mesh ARRAY1 ARRAY2 [ ARRAY3 ... ]

  =item zip ARRAY1 ARRAY2 [ ARRAY3 ... ]

  Returns a list consisting of the first elements of each array, then
  the second, then the third, etc, until all arrays are exhausted.

  Examples:

      @x = qw/a b c d/;
      @y = qw/1 2 3 4/;
      @z = mesh @x, @y;	    # returns a, 1, b, 2, c, 3, d, 4

      @a = ('x');
      @b = ('1', '2');
      @c = qw/zip zap zot/;
      @d = mesh @a, @b, @c;   # x, 1, zip, undef, 2, zap, undef, undef, zot

  C<zip> is an alias for C<mesh>.

  =item uniq LIST

  Returns a new list by stripping duplicate values in LIST. The order of
  elements in the returned list is the same as in LIST. In scalar context,
  returns the number of unique elements in LIST.

      my @x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 1 2 3 5 4
      my $x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 5

  =item minmax LIST

  Calculates the minimum and maximum of LIST and returns a two element list with
  the first element being the minimum and the second the maximum. Returns the empty
  list if LIST was empty.

  The minmax algorithm differs from a naive iteration over the list where each element
  is compared to two values being the so far calculated min and max value in that it
  only requires 3n/2 - 2 comparisons. Thus it is the most efficient possible algorithm.

  However, the Perl implementation of it has some overhead simply due to the fact
  that there are more lines of Perl code involved. Therefore, LIST needs to be
  fairly big in order for minmax to win over a naive implementation. This
  limitation does not apply to the XS version.

  =item part BLOCK LIST

  Partitions LIST based on the return value of BLOCK which denotes into which partition
  the current value is put.

  Returns a list of the partitions thusly created. Each partition created is a
  reference to an array.

      my $i = 0;
      my @part = part { $i++ % 2 } 1 .. 8;   # returns [1, 3, 5, 7], [2, 4, 6, 8]

  You can have a sparse list of partitions as well where non-set partitions will
  be undef:

      my @part = part { 2 } 1 .. 10;	    # returns undef, undef, [ 1 .. 10 ]

  Be careful with negative values, though:

      my @part = part { -1 } 1 .. 10;
      __END__
      Modification of non-creatable array value attempted, subscript -1 ...

  Negative values are only ok when they refer to a partition previously created:

      my @idx = (0, 1, -1);
      my $i = 0;
      my @part = part { $idx[$++ % 3] } 1 .. 8;	# [1, 4, 7], [2, 3, 5, 6, 8]

  =back


pkgId: 04d81d29d94c3cf5788acf7500df7f65b5f6071c
name: local-perl-List-MoreUtils
arch: src
version: 0.32
epoch: 0
release: 1
summary: List-MoreUtils - Provide the stuff missing in List::Util
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Tassilo von Parseval <tassilo.von.parseval@rwth-aachen.de>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-List-MoreUtils-0.32-1.src.rpm
checksum_type: sha
description:
  B<List::MoreUtils> provides some trivial but commonly needed functionality on
  lists which is not going to go into L<List::Util>.

  All of the below functions are implementable in only a couple of lines of Perl
  code. Using the functions from this module however should give slightly better
  performance as everything is implemented in C. The pure-Perl implementation of
  these functions only serves as a fallback in case the C portions of this module
  couldn't be compiled on this machine.

  =over 4

  =item any BLOCK LIST

  Returns a true value if any item in LIST meets the criterion given through
  BLOCK. Sets C<$_> for each item in LIST in turn:

      print "At least one value undefined"
          if any { ! defined($_) } @list;

  Returns false otherwise, or if LIST is empty.

  =item all BLOCK LIST

  Returns a true value if all items in LIST meet the criterion given through
  BLOCK, or if LIST is empty. Sets C<$_> for each item in LIST in turn:

      print "All items defined"
          if all { defined($_) } @list;

  Returns false otherwise.

  =item none BLOCK LIST

  Logically the negation of C<any>. Returns a true value if no item in LIST meets
  the criterion given through BLOCK, or if LIST is empty. Sets C<$_> for each item
  in LIST in turn:

      print "No value defined"
          if none { defined($_) } @list;

  Returns false otherwise.

  =item notall BLOCK LIST

  Logically the negation of C<all>. Returns a true value if not all items in LIST
  meet the criterion given through BLOCK. Sets C<$_> for each item in LIST in
  turn:

      print "Not all values defined"
          if notall { defined($_) } @list;

  Returns false otherwise, or if LIST is empty.

  =item true BLOCK LIST

  Counts the number of elements in LIST for which the criterion in BLOCK is true.
  Sets C<$_> for  each item in LIST in turn:

      printf "%i item(s) are defined", true { defined($_) } @list;

  =item false BLOCK LIST

  Counts the number of elements in LIST for which the criterion in BLOCK is false.
  Sets C<$_> for each item in LIST in turn:

      printf "%i item(s) are not defined", false { defined($_) } @list;

  =item firstidx BLOCK LIST

  =item first_index BLOCK LIST

  Returns the index of the first element in LIST for which the criterion in BLOCK
  is true. Sets C<$_> for each item in LIST in turn:

      my @list = (1, 4, 3, 2, 4, 6);
      printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
      __END__
      item with index 1 in list is 4

  Returns C<-1> if no such item could be found.

  C<first_index> is an alias for C<firstidx>.

  =item lastidx BLOCK LIST

  =item last_index BLOCK LIST

  Returns the index of the last element in LIST for which the criterion in BLOCK
  is true. Sets C<$_> for each item in LIST in turn:

      my @list = (1, 4, 3, 2, 4, 6);
      printf "item with index %i in list is 4", lastidx { $_ == 4 } @list;
      __END__
      item with index 4 in list is 4

  Returns C<-1> if no such item could be found.

  C<last_index> is an alias for C<lastidx>.

  =item insert_after BLOCK VALUE LIST

  Inserts VALUE after the first item in LIST for which the criterion in BLOCK is
  true. Sets C<$_> for each item in LIST in turn.

      my @list = qw/This is a list/;
      insert_after { $_ eq "a" } "longer" => @list;
      print "@list";
      __END__
      This is a longer list

  =item insert_after_string STRING VALUE LIST

  Inserts VALUE after the first item in LIST which is equal to STRING.

      my @list = qw/This is a list/;
      insert_after_string "a", "longer" => @list;
      print "@list";
      __END__
      This is a longer list

  =item apply BLOCK LIST

  Applies BLOCK to each item in LIST and returns a list of the values after BLOCK
  has been applied. In scalar context, the last element is returned.  This
  function is similar to C<map> but will not modify the elements of the input
  list:

      my @list = (1 .. 4);
      my @mult = apply { $_ *= 2 } @list;
      print "\@list = @list\n";
      print "\@mult = @mult\n";
      __END__
      @list = 1 2 3 4
      @mult = 2 4 6 8

  Think of it as syntactic sugar for

      for (my @mult = @list) { $_ *= 2 }

  =item before BLOCK LIST

  Returns a list of values of LIST upto (and not including) the point where BLOCK
  returns a true value. Sets C<$_> for each element in LIST in turn.

  =item before_incl BLOCK LIST

  Same as C<before> but also includes the element for which BLOCK is true.

  =item after BLOCK LIST

  Returns a list of the values of LIST after (and not including) the point
  where BLOCK returns a true value. Sets C<$_> for each element in LIST in turn.

      @x = after { $_ % 5 == 0 } (1..9);    # returns 6, 7, 8, 9

  =item after_incl BLOCK LIST

  Same as C<after> but also inclues the element for which BLOCK is true.

  =item indexes BLOCK LIST

  Evaluates BLOCK for each element in LIST (assigned to C<$_>) and returns a list
  of the indices of those elements for which BLOCK returned a true value. This is
  just like C<grep> only that it returns indices instead of values:

      @x = indexes { $_ % 2 == 0 } (1..10);   # returns 1, 3, 5, 7, 9

  =item firstval BLOCK LIST

  =item first_value BLOCK LIST

  Returns the first element in LIST for which BLOCK evaluates to true. Each
  element of LIST is set to C<$_> in turn. Returns C<undef> if no such element
  has been found.

  C<first_val> is an alias for C<firstval>.

  =item lastval BLOCK LIST

  =item last_value BLOCK LIST

  Returns the last value in LIST for which BLOCK evaluates to true. Each element
  of LIST is set to C<$_> in turn. Returns C<undef> if no such element has been
  found.

  C<last_val> is an alias for C<lastval>.

  =item pairwise BLOCK ARRAY1 ARRAY2

  Evaluates BLOCK for each pair of elements in ARRAY1 and ARRAY2 and returns a
  new list consisting of BLOCK's return values. The two elements are set to C<$a>
  and C<$b>.  Note that those two are aliases to the original value so changing
  them will modify the input arrays.

      @a = (1 .. 5);
      @b = (11 .. 15);
      @x = pairwise { $a + $b } @a, @b;	# returns 12, 14, 16, 18, 20

      
      @a = qw/a b c/;
      @b = qw/1 2 3/;
      @x = pairwise { ($a, $b) } @a, @b;	# returns a, 1, b, 2, c, 3

  =item each_array ARRAY1 ARRAY2 ...

  Creates an array iterator to return the elements of the list of arrays ARRAY1,
  ARRAY2 throughout ARRAYn in turn.  That is, the first time it is called, it
  returns the first element of each array.  The next time, it returns the second
  elements.  And so on, until all elements are exhausted.

  This is useful for looping over more than one array at once:

      my $ea = each_array(@a, @b, @c);
      while ( my ($a, $b, $c) = $ea->() )   { .... }

  The iterator returns the empty list when it reached the end of all arrays.

  If the iterator is passed an argument of 'C<index>', then it retuns
  the index of the last fetched set of values, as a scalar.

  =item each_arrayref LIST

  Like each_array, but the arguments are references to arrays, not the
  plain arrays.

  =item natatime EXPR, LIST

  Creates an array iterator, for looping over an array in chunks of
  C<$n> items at a time.  (n at a time, get it?).  An example is
  probably a better explanation than I could give in words.

  Example:

      my @x = ('a' .. 'g');
      my $it = natatime 3, @x;
      while (my @vals = $it->())
      {
          print "@vals\n";
      }

  This prints

      a b c
      d e f
      g

  =item mesh ARRAY1 ARRAY2 [ ARRAY3 ... ]

  =item zip ARRAY1 ARRAY2 [ ARRAY3 ... ]

  Returns a list consisting of the first elements of each array, then
  the second, then the third, etc, until all arrays are exhausted.

  Examples:

      @x = qw/a b c d/;
      @y = qw/1 2 3 4/;
      @z = mesh @x, @y;	    # returns a, 1, b, 2, c, 3, d, 4

      @a = ('x');
      @b = ('1', '2');
      @c = qw/zip zap zot/;
      @d = mesh @a, @b, @c;   # x, 1, zip, undef, 2, zap, undef, undef, zot

  C<zip> is an alias for C<mesh>.

  =item uniq LIST

  =item distinct LIST

  Returns a new list by stripping duplicate values in LIST. The order of
  elements in the returned list is the same as in LIST. In scalar context,
  returns the number of unique elements in LIST.

      my @x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 1 2 3 5 4
      my $x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 5

  =item minmax LIST

  Calculates the minimum and maximum of LIST and returns a two element list with
  the first element being the minimum and the second the maximum. Returns the
  empty list if LIST was empty.

  The C<minmax> algorithm differs from a naive iteration over the list where each
  element is compared to two values being the so far calculated min and max value
  in that it only requires 3n/2 - 2 comparisons. Thus it is the most efficient
  possible algorithm.

  However, the Perl implementation of it has some overhead simply due to the fact
  that there are more lines of Perl code involved. Therefore, LIST needs to be
  fairly big in order for C<minmax> to win over a naive implementation. This
  limitation does not apply to the XS version.

  =item part BLOCK LIST

  Partitions LIST based on the return value of BLOCK which denotes into which
  partition the current value is put.

  Returns a list of the partitions thusly created. Each partition created is a
  reference to an array.

      my $i = 0;
      my @part = part { $i++ % 2 } 1 .. 8;   # returns [1, 3, 5, 7], [2, 4, 6, 8]

  You can have a sparse list of partitions as well where non-set partitions will
  be undef:

      my @part = part { 2 } 1 .. 10;	    # returns undef, undef, [ 1 .. 10 ]

  Be careful with negative values, though:

      my @part = part { -1 } 1 .. 10;
      __END__
      Modification of non-creatable array value attempted, subscript -1 ...

  Negative values are only ok when they refer to a partition previously created:

      my @idx  = ( 0, 1, -1 );
      my $i    = 0;
      my @part = part { $idx[$++ % 3] } 1 .. 8; # [1, 4, 7], [2, 3, 5, 6, 8]

  =back


pkgId: e35d95981b23ce0d402f4918233a3faf13d08fdb
name: local-perl-Locale-Maketext-Simple
arch: src
version: 0.21
epoch: 0
release: 1
summary: Locale-Maketext-Simple - Simple interface to Locale::Maketext::Lexicon
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Audrey Tang <cpan AT audreyt DOT org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Locale-Maketext-Simple-0.21-1.src.rpm
checksum_type: sha
description:
  This module is a simple wrapper around B<Locale::Maketext::Lexicon>,
  designed to alleviate the need of creating I<Language Classes> for
  module authors.

  The language used is chosen from the loc_lang call. If a lookup is not
  possible, the i-default language will be used. If the lookup is not in the
  i-default language, then the key will be returned.

  If B<Locale::Maketext::Lexicon> is not present, it implements a
  minimal localization function by simply interpolating C<[_1]> with
  the first argument, C<[_2]> with the second, etc.  Interpolated
  function like C<[quant,_1]> are treated as C<[_1]>, with the sole
  exception of C<[tense,_1,X]>, which will append C<ing> to C<_1> when
  X is C<present>, or appending C<ed> to <_1> otherwise.


pkgId: 70f8e375ecd85014243367e60f00b777affa735c
name: local-perl-Locales
arch: src
version: 0.26
epoch: 0
release: 1
summary: Locales - Methods for getting localized CLDR language/territory names (and a subset of other data)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Daniel Muey <http://drmuey.com/cpan_contact.pl>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Locales-0.26-1.src.rpm
checksum_type: sha
description:
  Locales lets you create an object for a certain locale that lets you access certain data harvested directly from CLDR.

  L<http://cldr.unicode.org/index/downloads>

  Currently the data/methods include translated locale names and territory names.

  For simplicity Locales does not work with or know about Variants or Scripts. It only knows about languages and territories.

  Also it does not conatin all the data contained in CLDR. For example, L<DateTime>'s localization already has all the calender/date/time info from CLDR. Other information has not had any demand yet.

  For consistency all data is written in utf-8. No conversion should be necessary if you are (wisely) using utf-8 as your character set everywhere (See L<http://drmuey.com\/?do=page&id=57> for more info on that.).

  Note: You probably [don't need to/should not] use L<utf8> in regards to the data contained herein.


pkgId: de4a05f5c8c4ac1336d3a711b7f57683fe984f01
name: local-perl-LockFile-Simple
arch: src
version: 0.207
epoch: 0
release: 1
summary: LockFile-Simple - simple file locking scheme
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Raphael Manfredi <FEltRaphael_Manfredi@pobox.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-LockFile-Simple-0.207-1.src.rpm
checksum_type: sha
description:
  This simple locking scheme is not based on any file locking system calls
  such as C<flock()> or C<lockf()> but rather relies on basic file system
  primitives and properties, such as the atomicity of the C<write()> system
  call. It is not meant to be exempt from all race conditions, especially over
  NFS. The algorithm used is described below in the B<ALGORITHM> section.

  It is possible to customize the locking operations to attempt locking
  once every 5 seconds for 30 times, or delete stale locks (files that are
  deemed too ancient) before attempting the locking.


pkgId: f13b0fae1684f1c7117773f83643e4bde05d3c45
name: local-perl-Log-Agent
arch: src
version: 0.307
epoch: 0
release: 1
summary: Log-Agent - logging agent
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Raphael Manfredi <FEltRaphael_Manfredi@pobox.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Log-Agent-0.307-1.src.rpm
checksum_type: sha
description:
  The C<Log::Agent> module provides an abstract layer for logging and
  tracing, which is independant from the actual method used to physically
  perform those activities. It acts as an agent (hence the name) that
  collects the requests and delegates processing to a sublayer: the
  logging driver.

  The C<Log::Agent> module is meant to be used in all reusable components,
  since they cannot know in advance how the application which ends up using
  them will perform its logging activities: either by emitting messages
  on stdout and errors on stderr, or by directing messages to logfiles,
  or by using syslog(3).

  The logging interface is common for all the logging drivers, and is
  therefore the result of a compromise between many logging schemes: any
  information given at this level must be either handled by all drivers,
  or may be ignored depending on the application's final choice.

  WARNING: THIS INTERFACE IS STILL SOMEWHAT ALPHA AND COULD STILL CHANGE
  DEPENDING ON THE FEEDBACK I SHALL GET FROM USERS AND FROM MY OWN
  EXPERIENCE USING IT, WITHOUT ANY BACKWARD COMPATIBILITY ASSURANCE.


pkgId: 18e9015a24d36b43f7e2a8ebe1162bc461b01e35
name: local-perl-Log-Agent-Rotate
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Log-Agent-Rotate - parameters for logfile rotation
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Raphael Manfredi <FEltRaphael_Manfredi@pobox.comEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel5-build64.endpoint.com
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Log-Agent-Rotate-0.1.3-1.src.rpm
checksum_type: sha
description:
  The C<Log::Agent::Rotate> class holds the parameters describing the logfile
  rotation policy, and is meant to be supplied to instances of
  C<Log::Agent::Driver::File> via arguments in the creation routine,
  such as C<-rotate>, or by using array references as values in the
  C<-channels> hashref: See complementary information in
  L<Log::Agent::Driver::File>.

  As rotation cycles are performed, the current logfile is renamed, and
  possibly compressed, until the maximum backlog is reached, at which time
  files are deleted.  Assuming a backlog of 5 and that the latest 2 files
  are not compressed, the following files can be present on the filesystem:

      logfile           # the current logfile
      logfile.0         # most recently renamed logfile
      logfile.1
      logfile.2.gz
      logfile.3.gz
      logfile.4.gz      # oldest logfile, unlinked next cycle

  The following I<switches> are available to the creation routine make(),
  listed in alphabetical order, all taking a single integer value as argument:

  =over 4

  =item I<backlog>

  The total amount of old logfiles to keep, besides the current logfile.

  Defaults to 7.

  =item I<is_alone>

  The argument is a boolean stating whether the program writing to the logfile
  will be the only one or not.  This is a hint that drives some optimizations,
  but it is up to the program to B<guarantee> that noone else will be able to
  write to or unlink the current logfile when set to I<true>.

  Defaults to I<false>.

  =item I<max_size>

  The maximum logfile size.  This is a threshold, which will cause
  a logfile rotation cycle to be performed, when crossed after a write to
  the file.  If set to C<0>, this threshold is not checked.

  Defaults to 1 megabyte.

  =item I<max_time>

  The maximum time in seconds between the moment we opened the file and
  the next rotation cycle occurs.  This threshold is only checked after
  a write to the file.

  The value can also be given as a string, postfixed by one of the
  following letters to specify the period unit (e.g. "3w"):

      Letter   Unit
      ------   -------
         m     minutes
         h     hours
         d     days
         d     days
         w     weeks
         M     months (30 days of 24 hours)
         y     years

  Defaults to C<0>, meaning it is not checked.

  =item I<max_write>

  The maximum amount of data we can write to the logfile.  Like C<max_size>,
  this is a threshold, which is only checked after a write to the logfile.
  This is not the total logfile size: if several programs write to the same
  logfile and C<max_size> is not used, then the logfiles may never be rotated
  at all if none of the programs write at least C<max_write> bytes to the
  logfile before exiting.

  Defaults to C<0>, meaning it is not checked.

  =item I<single_host>

  The argument is a boolean stating whether the access to the logfiles
  will be made from one single host or not.  This is a hint that drives some
  optimizations, but it is up to the program to B<guarantee> that it is
  accurately set.

  Defaults to I<false>, which is always a safe value.

  =item I<unzipped>

  The amount of old logfiles, amongst the most recent ones, that should
  not be compressed but be kept as plain files.

  Defaults to 1.

  =back

  To test whether two configurations are strictly identical, use is_same(),
  as in:

      print "identical\n" if $x->is_same($y);

  where both $x and $y are C<Log::Agent::Rotate> objects.

  All the aforementionned switches also have a corresponding querying
  routine that can be issued on instances of the class to get their value.
  It is not possible to modify those attributes.

  For instance:

      my $x = Log::Agent::Rotate->make(...);
      my $mwrite = $x->max_write();

  would get the configured I<max_write> threshold.


