Ports 搜索

Roles are composable units of behavior. They are useful for factoring out functionality common to many classes from any part of your class hierarchy. See Moose::Cookbook::Roles::Recipe1 for an introduction to Moose::Role. While combining roles affords you a great deal of flexibility, individual roles have very little in the way of configurability. Core Moose provides alias for renaming methods and excludes for ignoring methods. These options are primarily (perhaps solely) for disambiguating role conflicts. See Moose::Cookbook::Roles::Recipe2 for more about alias and excludes. Because roles serve many different masters, they usually provide only the least common denominator of functionality. To empower roles further, more configurability than alias and excludes is required. Perhaps your role needs to know which method to call when it is done. Or what default value to use for its url attribute. Parameterized roles offer exactly this solution.

POEx::Role::Streaming provides a common idiom for streaming data from one filehandle to another. It accomplishes this by making good use of sysread and POE::Wheel::ReadWrite. This Role errs on the side of doing as many blocking reads of the "input_handle" as possible up front (until the high water mark is hit on the Wheel). If this default isn't suitable for the consumer, simply override "get_data_from_input_handle". After Streamer has exhausted the source, and flushed the last of the output, it will clean up after itself by closing the wheel, the handles, and sending all of them out of scope. If an exception happens, it will clean up after itself, and let the DIE signal propagate.

pty is a tool to help debug console programs which take the terminal out of canonical mode, by allowing the program being debugged and the debugger to run on separate terminal devices. To use pty, the programmer changes to the terminal device where he or she wishes to interact with the program to be debugged, and at the shell prompt, runs pty with no arguments. Pty will print out the filename of the slave side of the pseudo-terminal it has opened. Inside the debugger, running in another terminal device, one then redirects the program to be debugged's IO to the slave (tty command of gdb). When you are finished using pty, you must manually kill it. When pty starts it prints out its pid.

Test::Mock::LWP::Dispatch intends for testing a code that heavily uses LWP::UserAgent. Assume that function you want to test makes three different request to the server and expects to get some content from the server. To test this function you should setup request/response mappings for mocked UserAgent and test it. For doing something with mappings, here are methods map, unmap and unmap_all. For controlling context of these mappings (is it applies for all created in your code LWP::UserAgent's or only to one specific?) you should call these functions for exported $mock_ua object (global mapping) or for newly created LWP::UserAgent (local mappings). See also on Test::Mock::LWP, it provides mocked LWP objects for you, so probably you can solve your problems with this module too.

This module provides the ability to use references as hash keys if you first "tie" the hash variable to this module. Normally, only the keys of the tied hash itself are preserved as references; to use references as keys in hashes-of-hashes, use Tie::RefHash::Nestable, included as part of Tie::RefHash. It is implemented using the standard perl TIEHASH interface. Please see the "tie" entry in perlfunc(1) and perltie(1) for more information. The Nestable version works by looking for hash references being stored and converting them to tied hashes so that they too can have references as keys. This will happen without warning whenever you store a refer- ence to one of your own hashes in the tied hash.

pipestatus - source file for POSIX shell that allows to obtain an exit status of every program in a pipe. MOTIVATION When we program in shell we often run pipes like this prog1 args1 | prog2 args2 | ... | progN argsN POSIX says that exit status of pipe is the exit status of LAST program in it, i.e. progN in our example. That is, exit status of all other programs in pipe is silently ignored. But in many situations exit status of all programs in pipe should be checked to make program robust. Some shells like BASH and ZSH have special extensions for doing this but POSIX shell unfortunately doesn't provide an EASY way for doing this. In order to solve the problem, described above pipestatus was written.

Yapps (Yet Another Python Parser System) is an easy to use parser generator that is written in Python and generates Python code. Yapps is simple, is easy to use, and produces human-readable parsers. It is not fast, powerful, or particularly flexible. Yapps is designed to be used when regular expressions are not enough and other parser systems are too much: situations where you may write your own recursive descent parser. Yapps 1 is more like a functional language (concise grammars of the form when you see this, return this), while Yapps 2 is more like an imperative language (more verbose grammars of the form if/while you see this, do this). Yapps 2 is more flexible than Yapps 1 but it requires Python 1.5 and is not backwards-compatible with Yapps 1. This is the development version of Yapps 2.

repoze.what is an authorization framework for WSGI applications, based on repoze.who (which deals with authentication and identification). On the one hand, it enables an authorization system based on the groups to which the `authenticated or anonymous` user belongs and the permissions granted to such groups by loading these groups and permissions into the request on the way in to the downstream WSGI application. And on the other hand, it enables you to manage your groups and permissions from the application itself or another program, under a backend-independent API. For example, it would be easy for you to switch from one back-end to another, and even use this framework to migrate the data.

The Ada 95 Booch components are a port of Grady Booch's C++ components. They contain the same key abstractions as the C++ form (Structs, Tools and Support). However, the organization is slightly different, particularly in the Support domain. This is because Ada 95 provides several special forms of memory management that are quite different from C++. The Structs category provides an array of structural abstractions (Bags, Collections, Deques, Graphs, Lists, Maps, Queues, Rings, Sets, Stacks, and Trees). The Tools category provides algorithmic abstractions (Searching, Sorting, etc.). The Support category contains all the "concrete" forms, plus structures to create the components. Some of the structures permit structural sharing (graphs, lists, and trees). Some structures may also be ordered (collections, dequeues, and queues). There are also multiple forms for some structures: single and double linked lists, directed and undirected graphs, and binary, multiway, and AVL trees.

Many C++ developers miss an easy and portable way of handling Unicode encoded strings. The original C++ Standard (known as C++98 or C++03) is Unicode agnostic. C++11 provides some support for Unicode on core language and library level: u8, u, and U character and string literals, char16_t and char32_t character types, u16string and u32string library classes, and codecvt support for conversions between Unicode encoding forms. In the meantime, developers use third party libraries like ICU, OS specific capabilities, or simply roll out their own solutions. In order to easily handle UTF-8 encoded Unicode strings, I came up with a small generic library. For anybody used to work with STL algorithms and iterators, it should be easy and natural to use.