Ports 搜索

The T2 module is a base for the refactoring of the now quite stable Tangram Object-Relational mapper. In a nutshell, it lets you store objects - which have to be described to a similar level that you would describe a database to store them - into any SQL store. Currently, this is tested on PostgreSQL, MySQL, Oracle and Sybase a lot, though in general database-specific extensions to SQL, such as triggers, stored procedures, etc are avoided. So, if DBI installs and tests successfully with your database, there is a good chance that T2 will work with it too. The only current requirement is that objects that have tables associated with them are implemented via hashes. You also have to be able to describe all of the fields for those root objects. Individual fields of stored objects may be arbitrarily complex. If you are familiar with DBI, it is somewhat similar to bless'ing the structures returned by $dbh->fetchrow_hashref, except that references and collections to other objects in the store are loaded `on demand' (aka Lazy-loading).

FC++ is a library for functional programming in C++. Functional programming is a programming paradigm in which functions are treated as regular values. Thus, we can have functions that take other functions as parameters. The former functions are called "higher-order" functions. A common feature of functions is that they can be polymorphic. "Polymorphic" means that the same function can be used with arguments of many types. FC++ is distinguished from other libraries (including the C++ Standard Library) by its complete support for polymorphism: FC++ polymorphic higher-order functions can take other polymorphic functions as arguments and return polymorphic functions as results. This is particularly useful (i.e., simplifies code) in C++ where type inference is limited and we often need to pass polymorphic functions around and determine their type later. With FC++ you can define your own higher-order polymorphic functions, but the library also contains a large amount of functionality that can be re-used as-is in C++ programs. This includes infinite ("lazy") lists, useful higher-order functions (like map, compose, etc.), a reference-counting facility that can be used to replace C++ pointers, many common logical and arithmetic operators in a form that can be used with higher-order functions, and more.

This module provides perl access to Glib and GLib's GObject libraries. GLib is a portability and utility library; GObject provides a generic type system with inheritance and a powerful signal system. Together these libraries are used as the foundation for many of the libraries that make up the Gnome environment, and are used in many unrelated projects. 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. Where GLib's functionality overlaps perl's, perl's is favored; for example, you will find perl lists and arrays in place of GSList or GList objects. Some concepts have been eliminated; you need never worry about reference-counting on GObjects or GBoxed structures. Other concepts have been converted to a perlish analogy; the GType id will never be seen in perl, as the package name serves that purpose. [FIXME link to a document describing this stuff in detail.]

Luka is an exception handling and reporting framework. It's useful to look at it as an event handling framework. It comes from operational understanding of networks. Scenario that Luka is addressing is following: on a network with multiple hosts running multiple applications, it is very difficult to track operational status of all the functionality that those applications and hosts are meant to deliver. In order to make it easier, we decided to specify the error handling and reporting data model that each component delivering functionality has to conform to. What is a component? In most cases, it is a script, often run from cronjob, in some cases it is a class in an application. In all cases, a component has to successfully complete a task on which functionality of an application, or entire network, relies on. It is common practice that programmers choose their way of handling errors and reporting. Luka is an attempt to standardize that process. Its primary goal is to make it easier for smaller number of people to keep larger number of applications and networks running.

Test::Command intends to bridge the gap between the well tested functions and objects you choose and their usage in your programs. By examining the exit status, terminating signal, STDOUT and STDERR of your program you can determine if it is behaving as expected. This includes testing the various combinations and permutations of options and arguments as well as the interactions between the various functions and objects that make up your program. The various test functions below can accept either a command string or an array reference for the first argument. If the command is expressed as a string it is passed to system as is. If the command is expressed as an array reference it is dereferenced and passed to system as a list. The final argument for the test functions, $name, is optional. By default the $name is a concatenation of the test function name, the command string and the expected value. This construction is generally sufficient for identifying a failing test, but you may always specify your own $name if desired. Any of the test functions can be used as instance methods on a Test::Command object. This is done by dropping the initial $cmd argument and instead using arrow notation.

Skip test scripts if modules are not available. The requested modules will be loaded, and optionally have their versions checked. If the module is missing, the test script will be skipped. Modules that are found but fail to compile will exit with an error rather than skip. If used in a subtest, the remainder of the subtest will be skipped. Skipping will work even if some tests have already been run, or if a plan has been declared. Versions are checked via a $module->VERSION($wanted_version) call. Versions must be provided in a format that will be accepted. No extra processing is done on them. If perl is used as a module, the version is checked against the running perl version ($]). The version can be specified as a number, dotted-decimal string, v-string, or version object. If the RELEASE_TESTING environment variable is set, the tests will fail rather than skip. Subtests will be aborted, but the test script will continue running after that point.

Pyro is short for PYthon Remote Objects. It is an advanced and powerful Distributed Object Technology system written entirely in Python, that is designed to be very easy to use. Never worry about writing network communication code again, when using Pyro you just write your Python objects like you would normally. With only a few lines of extra code, Pyro takes care of the network communication between your objects once you split them over different machines on the network. All the gory socket programming details are taken care of, you just call a method on a remote object as if it were a local object! Pyro provides an object-oriented form of RPC. You can use Pyro within a single system but also use it for IPC. For those that are familiar with Java, Pyro resembles Java's Remote Method Invocation (RMI). It is less similar to CORBA - which is a system- and language independent Distributed Object Technology and has much more to offer than Pyro or RMI. But Pyro is small, simple and free!

SimpleParse is a BSD-licensed Python package providing a simple and fast parser generator using a modified version of the mxTextTools text-tagging engine. SimpleParse allows you to generate parsers directly from your EBNF grammar. Unlike most parser generators, SimpleParse generates single-pass parsers (there is no distinct tokenization stage), an approach taken from the predecessor project (mcf.pars) which attempted to create "autonomously parsing regex objects". The resulting parsers are not as generalized as those created by, for instance, the Earley algorithm, but they do tend to be useful for the parsing of computer file formats and the like (as distinct from natural language and similar "hard" parsing problems). As of version 2.1.0 the SimpleParse project includes a patched copy of the mxTextTools tagging library with the non-recursive rewrite of the core parsing loop. This means that you will need to build the extension module to use SimpleParse, but the effect is to provide a uniform parsing platform where all of the features of a give SimpleParse version are always available.

dnsjava is an implementation of DNS in Java. It supports all defined record types (including the DNSSEC types), and unknown types. It can be used for queries, zone transfers, and dynamic updates. It includes a cache which can be used by clients, and a minimal implementation of a server. It supports TSIG authenticated messages, partial DNSSEC verification, and EDNS0. dnsjava provides functionality above and beyond that of the InetAddress class. Since it is written in pure Java, dnsjava is fully threadable, and in many cases is faster than using InetAddress. dnsjava provides both high and low level access to DNS. The high level functions perform queries for records of a given name, type, and class, and return an array of records. There is also a clone of InetAddress, which is even simpler. A cache is used to reduce the number of DNS queries sent. The low level functions allow direct manipulation of DNS messages and records, as well as allowing additional resolver properties to be set.

QEMU is a FAST! processor emulator using dynamic translation to achieve good emulation speed. QEMU has two operating modes: * Full system emulation. In this mode, QEMU emulates a full system (for example a PC), including a processor and various peripherials. It can be used to launch different Operating Systems without rebooting the PC or to debug system code. * User mode emulation (Linux host only). In this mode, QEMU can launch Linux processes compiled for one CPU on another CPU. It can be used to launch the Wine Windows API emulator or to ease cross-compilation and cross-debugging. As QEMU requires no host kernel patches to run, it is very safe and easy to use. This is a slave port of emulators/qemu-sbruno to build only static bsd-user targets named like qemu-mips-static. While still being experimental people have already built quite a few armv6/mips/mips64 packages using these and e.g. poudriere. Some notes are also here: http://wiki.freebsd.org/QemuUserModeHowTo