Ports Search

DateTime::Format::Oracle may be used to convert Oracle date and timestamp values into DateTime objects. It also can take a DateTime object and produce a date string matching the NLS_DATE_FORMAT. Oracle has flexible date formatting via its 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 NLS_DATE_FORMAT. Timestamp values will match either the NLS_TIMESTAMP_FORMAT or 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 %ENV hash must also be updated.

Envisage is a Python-based framework for building extensible applications, that is, applications whose functionality can be extended by adding "plug-ins". Envisage provides a standard mechanism for features to be added to an application, whether by the original developer or by someone else. In fact, when you build an application using Envisage, the entire application consists primarily of plug-ins. In this respect, it is similar to the Eclipse and Netbeans frameworks for Java applications. Each plug-in is able to: * Advertise where and how it can be extended (its "extension points"). * Contribute extensions to the extension points offered by other plug-ins. * Create and share the objects that perform the real work of the application ("services"). The Envisage project provides the basic machinery of the Envisage framework.

z80asm is an assembler for the Z80 microprcessor. The assembler aims to be portable and complete. Of course it assembles all official mnemonics, but it also aims to assemble the unofficial mnemonics. The assembler features the output of listing files which show the source with the assembled codes and address next to it. It also allows outputting of label files, in a format which can be included by other assembler source files. Other noteworthy features are complete calculation capabilities, conditional assembling of parts of the code, and inclusion of other source files. The assembler was written with the MSX computer in mind as the target platform, but it can be used for any system with a Z80 in it. The original idea was to make header files with labels of MSX specific addresses (BIOS, BDOS, system variables), but nothing like this has been done yet.

Math::Symbolic::Custom::Transformation is an extension to the Math::Symbolic module. You're assumed to be remotely familiar with that module throughout the documentation. This package implements transformations of Math::Symbolic trees using Math::Symbolic trees. I'll try to explain what this means in the following paragraphs. Until now, in order to be able to inspect a Math::Symbolic tree, one had to use the low-level Math::Symbolic interface like comparing the top node's term type with a constant (such as T_OPERATOR) and then its operator type with more constants. This has changed with the release of Math::Symbolic::Custom::Pattern. To modify the tree, you had to use equally low-level or even encapsulation-breaking methods. This is meant to be changed by this distribution.

The Zillion Project is a distributed computing project reminiscent of the good old Zilla.app of NeXTstep days. It is based on GNUstep, the most promising OPENSTEP replacement as of today. Jobs can be created from simple template projects and can be submitted with a single command to the Zillion Server which in turn will distribute the job amongst the registered clients. No other network resources than the distributed objects (DO) port of the server machine has to be available. The key features are as follows: * Rapid turn around cycles for job submission * Dynamic addition/removal of client nodes * Full OO-design * No need for shared network resources * Real-time capabilities * Lean and clean * Open and free LICENSE: BSD

- Much from HTML 4.0 - that is relevant for printing - is supported (incidentally, the PostScript and PDF versions of the HTML 4.0 draft, were generated using html2ps). For example, all character entities (except ‌, ‍, ‎, and ‏) are supported. - Many possibilities to control the appearance. Starting with this version, this is mostly done using configuration files. - Support for processing multiple documents, also automatically by recursively following links. - A table of contents can be generated, either from the links in a document, or automatically from document headings. - Configurable page headers/footers, that for example can contain document title, URL, page number, current heading, and date. - When converting the PostScript document to PDF - using some other program such as version 5.0 or later of Aladdin Ghostscript, or Adobe Acrobat Distiller - the original hyperlinks in the HTML documents will be retained in the PDF document. - Automatic hyphenation and text justification can be selected.

Firewall Builder consists of object-oriented GUI and set of policy compilers for various firewall platforms. In Firewall Builder, firewall policy is a set of rules, each rule consists of abstract objects which represent real network objects and services (hosts, routers, firewalls, networks, protocols). Firewall Builder helps user maintain database of objects and allows policy editing using simple drag-and-drop operations. Preferences and objects databases are stored in XML format. GUI and policy compilers are completely independent. Support for a new firewall platform can be added to GUI without any changes done to the program, although new policy compiler must be written. This provides for consistent abstract model and the same GUI for different firewall platforms. Currently three most popular free firewalls are supported: ipchains, iptables and ipfilter. Because of this, Firewall Builder can be used to manage firewalls built on variety of platforms including, but not limited to, Linux running ipchains or iptables and FreeBSD or Solaris running ipfilter.

[ excerpt from developer's www site ] The Cryptokit library for Objective Caml provides a variety of cryptographic primitives that can be used to implement cryptographic protocols in security-sensitive applications. The primitives provided include: Symmetric-key cryptography: AES, DES, Triple-DES, ARCfour, in ECB, CBC, CFB and OFB modes. Public-key cryptography: RSA encryption and signature; Diffie-Hellman key agreement. Hash functions and MACs: SHA-1, MD5, and MACs based on AES and DES. Random number generation. Encodings and compression: base 64, hexadecimal, Zlib compression. Additional ciphers and hashes can easily be used in conjunction with the library. In particular, basic mechanisms such as chaining modes, output buffering, and padding are provided by generic classes that can easily be composed with user-provided ciphers. More generally, the library promotes a "Lego"-like style of constructing and composing transformations over character streams.

There's a whole bunch of class builders out there. In fact, creating a class builder seems to be something of a rite of passage (this is my fifth, at least). Unfortunately, most of the time I want a class builder I'm in a hurry and sketching out lots of fairly simple data classes with fairly simple structure, mostly just read-only accessors, and that's about it. Often this is for code that won't end up on CPAN, so adding a small dependency doesn't matter much. I just want to be able to define these classes FAST. By which I mean LESS typing than writing them by hand, not more. And I don't need all those weird complex features that bloat out the code and take over the whole way I build modules. And so, I present yet another member of the Tiny family of modules, Object::Tiny.

This is a sister module of Parse::PMFile. This module parses local .pm files (and a META file if any) in a specific (current if not specified) directory, and returns a hash reference that represents "provides" information (with some extra meta data). This is almost the same as Module::Metadata does (which has been in Perl core since Perl 5.13.9). The main difference is the most of the code of this module is directly taken from the PAUSE code as of June 2013. If you need better compatibility to PAUSE, try this. If you need better performance, safety, or portability in general, Module::Metadata may be a better and handier option (Parse::PMFile (and thus Parse::LocalDistribution) actually evaluates code in the $VERSION line (in a Safe compartment), which may be problematic in some cases).