Ports 搜索

IO::Event provides an object-based callback system for handling nonblocking IO. The design goal is to provide a system that just does the right thing without the user needing to think about it much. All APIs are kept as simple as possible yet at the same time, all functionality is accesible if needed. Simple things are easy. Hard things are possible. Most of the time file handling syntax will work fine: <$filehandle> and print $filehandle 'stuff'. IO::Event provides automatic buffering of output (with a callback to throttle). It provides automatic line-at-a-time input. After initial setup, call IO::Event::loop(). IO::Event was originally written to use Event. IO::Event still defaults to using Event but it can now use AnyEvent or its own event loop.

Inline::TT provides Inline access to version 2.0 and higher of the Template Toolkit. This allows you to house your templates inside the source code file, while retaining the ability to cache compiled templates on the disk (via Inline's caching mechanism). The names of the blocks in the template are exported as functions. Call these with a reference to a hash of values, which will be used for interpolation in the templates. This hash reference is the same as the second argument to the process method of any Template object. The output from template toolkit will be returned to you as a single string. Note that leading and trailing spaces are trimmed, further the template toolkit options PRE_CHOMP and POST_CHOMP are set. Currently, there is no way to change these behaviors.

POE::Session::MultiDispatch is a drop in replacement for POE::Session that adds callback dispatch functionality to POE sessions. Each event may have multiple handlers associated with it. Fine control over the order of execution is available using helper methods that extend the interface of a POE::Session. POE::Session::MultiDispatch uses POE::Session as a base class. When multiple callbacks are registered for an event, only the last callback survives, all the others are clobbered. POE::Session::MultiDispatch is much nicer to your registered callbacks, it keeps them all in the order they were defined. When an event is triggered, all the callbacks are then executed in that same order (unless you muck around with said order).

The Perl garbage collector uses simple reference counting during the normal execution of a program. This means that cycles or unweakened references in other parts of code can keep an object around for longer than intended. To help avoid this problem, the reference count of a new object from its class constructor ought to be 1. This way, the caller can know the object will be properly DESTROYed when it drops all of its references to it. Test::Refcount provides two test functions to help ensure this property holds for an object class, so as to be polite to its callers. If the assertion fails; that is, if the actual reference count is different to what was expected, a trace of references to the object can be printed, if Marc Lehmann's Devel::FindRef module is installed. This may assist the developer in finding where the references are.

This module adds the ability to quickly create new types of tie objects without creating a complete class. It does so in such a way as to try and make the programmers life easier when it comes to single-use ties that I find myself wanting to use from time-to-time. The Tie::Simple package is actually a front-end to other classes which really do all the work once tied, but this package does the dwimming to automatically figure out what you're trying to do. I've tried to make this as intuitive as possible and dependent on other bits of Perl where I can to minimize the need for documentation and to make this extra, extra spiffy.

The Boehm-Weiser garbage collection package, for C and C++ - garbage collection and memory leak detection libraries. A garbage collector is something which automatically frees malloc'd memory for you by working out what parts of memory your program no longer has pointers to. As a result, garbage collectors can also inform you of memory leaks (if they find memory they can free, it means you have lost all of your pointers to it, but you didn't free it). C programs may be linked against either of these, and should run (with GC or leak detection) without change. C++ programs must include a header to use garbage collection, though leak detection should work without such source code modifications. See the man page and header files. ps: garbage collection is addictive.

HTML_Template_IT: Simple template API. The Isotemplate API is somewhat tricky for a beginner although it is the best one you can build. template::parse() [phplib template = Isotemplate] requests you to name a source and a target where the current block gets parsed into. Source and target can be block names or even handler names. Features : * Nested blocks * Include external file * Custom tags format (default {mytag}) HTML_Template_ITX : With this class you get the full power of the phplib template class. You may have one file with blocks in it but you have as well one main file and multiple files one for each block. This is quite useful when you have user configurable websites. Using blocks not in the main template allows you to modify some parts of your layout easily.

Haskell bindings to the International Components for Unicode (ICU) libraries. These libraries provide robust and full-featured Unicode services on a wide variety of platforms. Features include: * Both pure and impure bindings, to allow for fine control over efficiency and ease of use. * Breaking of strings on character, word, sentence, and line boundaries. * Access to the Unicode Character Database (UCD) of character metadata. * String collation functions, for locales where the conventions for lexicographic ordering differ from the simple numeric ordering of character codes. * Character set conversion functions, allowing conversion between Unicode and over 220 character encodings. * Unicode normalization. (When implementations keep strings in a normalized form, they can be assured that equivalent strings have a unique binary representation.) * Regular expression search and replace.

The PyPA recommended tool for installing and managing Python packages. pip is a replacement for easy_install. It uses mostly the same techniques for finding packages, so packages that were made easy_installable should be pip-installable as well. pip is meant to improve on easy_install. Some of the improvements: * All packages are downloaded before installation. Partially-completed installation doesn't occur as a result. * Care is taken to present useful output on the console. * The reasons for actions are kept track of. For instance, if a package is being installed, pip keeps track of why that package was required. * Error messages should be useful. * Packages don't have to be installed as egg archives, they can be installed flat (while keeping the egg metadata).

py-rioritized_methods is an extension to PEAK-Rules to prioritize methods in order to avoid AmbiguousMethods situations.This module provides four decorators: prioritized_when prioritized_around prioritized_before prioritized_after These behave like their peak.rules counterparts except that they accept an optional prio argument which can be used to provide a comparable object (usually an integer) that will be used to disambiguate situations in which more than rule applies to the given arguments and no rule is more specific than another. That is, situations in which an peak.rules.AmbiguousMethods would have been raised. This is useful for libraries which want to be extensible via generic functions but want their users to easily override a method without figuring out how to write a more specific rule or when it is not feasible.