event interface
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 5396
GnuPG::Interface 0.33
GnuPG::Interface is a Perl interface to GnuPG. more>>
GnuPG::Interface is a Perl interface to GnuPG.
SYNOPSIS
# A simple example
use IO::Handle;
use GnuPG::Interface;
# settting up the situation
my $gnupg = GnuPG::Interface->new();
$gnupg->options->hash_init( armor => 1,
homedir => /home/foobar );
# Note you can set the recipients even if you arent encrypting!
$gnupg->options->push_recipients( ftobin@cpan.org );
$gnupg->options->meta_interactive( 0 );
# how we create some handles to interact with GnuPG
my $input = IO::Handle->new();
my $output = IO::Handle->new();
my $handles = GnuPG::Handles->new( stdin => $input,
stdout => $output );
# Now well go about encrypting with the options already set
my @plaintext = ( foobar );
my $pid = $gnupg->encrypt( handles => $handles );
# Now we write to the input of GnuPG
print $input @plaintext;
close $input;
# now we read the output
my @ciphertext = ;
close $output;
waitpid $pid, 0;
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.
How Data Member Accessor Methods are Created
Each module in the GnuPG::Interface bundle relies on Class::MethodMaker to generate the get/set methods used to set the objects data members. This is very important to realize. This means that any data member which is a list has special methods assigned to it for pushing, popping, and clearing the list.
Understanding Bidirectional Communication
It is also imperative to realize that this package uses interprocess communication methods similar to those used in IPC::Open3 and "Bidirectional Communication with Another Process" in perlipc, and that users of this package need to understand how to use this method because this package does not abstract these methods for the user greatly. This package is not designed to abstract this away entirely (partly for security purposes), but rather to simply help create proper, clean calls to GnuPG, and to implement key-listing parsing. Please see "Bidirectional Communication with Another Process" in perlipc to learn how to deal with these methods.
Using this package to do message processing generally invovlves creating a GnuPG::Interface object, creating a GnuPG::Handles object, setting some options in its options data member, and then calling a method which invokes GnuPG, such as clearsign. One then interacts with with the handles appropriately, as described in "Bidirectional Communication with Another Process" in perlipc.
<<lessSYNOPSIS
# A simple example
use IO::Handle;
use GnuPG::Interface;
# settting up the situation
my $gnupg = GnuPG::Interface->new();
$gnupg->options->hash_init( armor => 1,
homedir => /home/foobar );
# Note you can set the recipients even if you arent encrypting!
$gnupg->options->push_recipients( ftobin@cpan.org );
$gnupg->options->meta_interactive( 0 );
# how we create some handles to interact with GnuPG
my $input = IO::Handle->new();
my $output = IO::Handle->new();
my $handles = GnuPG::Handles->new( stdin => $input,
stdout => $output );
# Now well go about encrypting with the options already set
my @plaintext = ( foobar );
my $pid = $gnupg->encrypt( handles => $handles );
# Now we write to the input of GnuPG
print $input @plaintext;
close $input;
# now we read the output
my @ciphertext = ;
close $output;
waitpid $pid, 0;
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.
How Data Member Accessor Methods are Created
Each module in the GnuPG::Interface bundle relies on Class::MethodMaker to generate the get/set methods used to set the objects data members. This is very important to realize. This means that any data member which is a list has special methods assigned to it for pushing, popping, and clearing the list.
Understanding Bidirectional Communication
It is also imperative to realize that this package uses interprocess communication methods similar to those used in IPC::Open3 and "Bidirectional Communication with Another Process" in perlipc, and that users of this package need to understand how to use this method because this package does not abstract these methods for the user greatly. This package is not designed to abstract this away entirely (partly for security purposes), but rather to simply help create proper, clean calls to GnuPG, and to implement key-listing parsing. Please see "Bidirectional Communication with Another Process" in perlipc to learn how to deal with these methods.
Using this package to do message processing generally invovlves creating a GnuPG::Interface object, creating a GnuPG::Handles object, setting some options in its options data member, and then calling a method which invokes GnuPG, such as clearsign. One then interacts with with the handles appropriately, as described in "Bidirectional Communication with Another Process" in perlipc.
Download (0.037MB)
Added: 2006-08-04 License: Perl Artistic License Price:
1176 downloads
VIDeo Interface for *niX 1.0.0
VIDeo Interface for *niX (VIDIX) is a portable interface to userspace drivers to provide DGA everywhere possible. more>>
VIDeo Interface for *niX (VIDIX) is a portable interface to userspace drivers to provide DGA everywhere possible. VIDIX is portable interface which was designed and introduced as interface to userspace drivers to provide DGA everywhere where its possible.
Enhancements:
- warnings suppressing
- fixes and improvements
- Win32 related improvements
- h/w revision detection for cle266 chipset
- support for Geforce FX5500
- added vt8378 chipset as unichrome driver
<<lessEnhancements:
- warnings suppressing
- fixes and improvements
- Win32 related improvements
- h/w revision detection for cle266 chipset
- support for Geforce FX5500
- added vt8378 chipset as unichrome driver
Download (0.31MB)
Added: 2007-04-07 License: LGPL (GNU Lesser General Public License) Price:
934 downloads
X Interface Monitor 1.8.4
X Interface Monitor monitors any network interface for traffic, load average, and various other statistics. more>>
X Interface Monitor (abbriviated xifmon) monitors any network interface (most suitable, the ppp# interface) for traffic, load average, and various other statistics using purly ioctl() directly to the Linux kernel.
It also has options to run `connect and `disconnect scripts, for dialup modem users who want easy connecting and disconnecting.
<<lessIt also has options to run `connect and `disconnect scripts, for dialup modem users who want easy connecting and disconnecting.
Download (0.49MB)
Added: 2005-10-13 License: GPL (GNU General Public License) Price:
1477 downloads
GNOME Interface for YUM 0.1.5
GNOME Interface for YUM is a graphical frame-program for easier use and setup the YUM install program. more>>
GNOME Interface for YUM is a graphical frame-program for easier use and setup the YUM install program.
Displays the accessible packages on the package service sites with filter. Manage the settings of package services.
Manage the cache used by YUM: free up disk space, manual install and transfer of downloaded packages. Displays detailed package information about the installed packages or package files. Displays the files in the packages with a program chosen by user.
<<lessDisplays the accessible packages on the package service sites with filter. Manage the settings of package services.
Manage the cache used by YUM: free up disk space, manual install and transfer of downloaded packages. Displays detailed package information about the installed packages or package files. Displays the files in the packages with a program chosen by user.
Download (0.57MB)
Added: 2006-11-17 License: GPL (GNU General Public License) Price:
1076 downloads
Java GForge SOAP Interface 0.0.10
Java GForge SOAP Interface is an approach to access the GForge collaboration platform via Java. more>>
Java GForge SOAP Interface (or JaGoSI for short) is an approach to access the GForge collaboration platform via Java. This can be used to put other applications on top of JaGoSI. It may be integrated with other applications like the former MyLar project.
Enhancements:
- A complete working file distribution is available for the GForge platform via an Ant task.
- Many bugs were fixed.
- The Maven build was fixed, so compiling with sub components is working.
- The project structure was changed.
- JUnit was updated to version 4.
<<lessEnhancements:
- A complete working file distribution is available for the GForge platform via an Ant task.
- Many bugs were fixed.
- The Maven build was fixed, so compiling with sub components is working.
- The project structure was changed.
- JUnit was updated to version 4.
Download (MB)
Added: 2007-08-13 License: Perl Artistic License Price:
804 downloads
Pandorabots Chat Bot Interface 1.0
Pandorabots Chat Bot Interface is a learning tool for implementing AJAX to communicate between the browser and a server. more>>
Pandorabots Chat Bot Interface project is a learning tool for implementing AJAX to communicate between the browser and a server. The chat bot interface communicates via XML with a free chat bot you create and host at pandorabots.com. The client script controlls a div that records your ongoing conversation. The final product is an embedded chat bot in your Web sit
An AI chat bot is nothing more than a computer program which has been trained to interact with humans using common communication languages. Some have the ability to learn on the fly, others have a "trainer" that tells them what to say for keywords, etc.
<<lessAn AI chat bot is nothing more than a computer program which has been trained to interact with humans using common communication languages. Some have the ability to learn on the fly, others have a "trainer" that tells them what to say for keywords, etc.
Download (MB)
Added: 2007-03-14 License: GPL (GNU General Public License) Price:
972 downloads
Realtime Application Interface 3.5
The Realtime Application Interface for Linux allows applications with strict timing constraints to be run on Linux. more>>
Realtime Application Interface project allows applications with strict timing constraints to be run on Linux.
A real time system is able to guarantee the timing requirements of the processes under its control.
RTAI provides an API and the necessary kernel modifications to accommodate such requirements.
Enhancements:
- Improvements were made to netrpc.
- Context switching between hard and soft real-time, handling of TSC errors, and POSIX compatibility have been improved.
- There are numerous minor bugfixes.
<<lessA real time system is able to guarantee the timing requirements of the processes under its control.
RTAI provides an API and the necessary kernel modifications to accommodate such requirements.
Enhancements:
- Improvements were made to netrpc.
- Context switching between hard and soft real-time, handling of TSC errors, and POSIX compatibility have been improved.
- There are numerous minor bugfixes.
Download (1.7MB)
Added: 2007-06-04 License: GPL (GNU General Public License) Price:
875 downloads
Imager::interface.pod 0.54
Imager::interface.pod decribes the C level virtual image interface. more>>
Imager::interface.pod decribes the C level virtual image interface.
The Imager virtual interface aims to allow image types to be created for special purposes, both to allow consistent access to images with different sample sizes, and organizations, but also to allow creation of synthesized or virtual images.
This is a C level interface rather than Perl.
<<lessThe Imager virtual interface aims to allow image types to be created for special purposes, both to allow consistent access to images with different sample sizes, and organizations, but also to allow creation of synthesized or virtual images.
This is a C level interface rather than Perl.
Download (0.83MB)
Added: 2006-10-27 License: Perl Artistic License Price:
1092 downloads
Event 1.09
Event is an Event loop processing. more>>
Event is an Event loop processing.
SYNOPSIS
use Event qw(loop unloop);
# initialize application
Event->flavor(attribute => value, ...);
my $ret = loop();
# and some callback will call
unloop(ok);
The Event module provide a central facility to watch for various types of events and invoke a callback when these events occur. The idea is to delay the handling of events so that they may be dispatched in priority order when it is safe for callbacks to execute.
Events (in the ordinary sense of the word) are detected by watchers, which reify them as events (in the special Event module sense). For clarity, the former type of events may be called "source events", and the latter "target events". Source events, such as signals arriving, happen whether or not they are being watched. If a source event occurs which a watcher is actively watching then the watcher generates a corresponding target event. Target events are only created by watchers. If several watchers are interested in the same source event then each will generate their own target event. Hence, any particular source event may result in zero, one, two, or any number of target events: the same as the number of watchers which were actively watching for it.
Target events are queued to be processed in priority order (priority being determined by the creating watcher) and in FIFO order among events of the same priority. Queued ("pending") events can, in some cases, be cancelled before being processed. A queued event is processed by being passed to the callback function (or method on a particular object or class) which was specified to the watcher.
A watcher, once created, operates autonomously without the Event user having to retain any reference to it. However, keeping a reference makes it possible to modify most of the watchers characteristics. A watcher can be switched between active and inactive states. When inactive, it does not generate target events.
Some types of source event are not reified as target events immediately. Signals received, for example, are counted initially. The counted signals are reified at certain execution points. Hence, signal events may be processed out of order, and if handled carelessly, on the wrong side of a state change in event handling. A useful way to view this is that occurrence of the source event is not actually the arrival of the signal but is triggered by the counting of the signal.
Reification can be forced when necessary. The schedule on which some other events are created is non-obvious. This is especially the case with watchers that watch for a condition rather than an event. In some cases, target events are generated on a schedule that depends on the operation of the event loop.
<<lessSYNOPSIS
use Event qw(loop unloop);
# initialize application
Event->flavor(attribute => value, ...);
my $ret = loop();
# and some callback will call
unloop(ok);
The Event module provide a central facility to watch for various types of events and invoke a callback when these events occur. The idea is to delay the handling of events so that they may be dispatched in priority order when it is safe for callbacks to execute.
Events (in the ordinary sense of the word) are detected by watchers, which reify them as events (in the special Event module sense). For clarity, the former type of events may be called "source events", and the latter "target events". Source events, such as signals arriving, happen whether or not they are being watched. If a source event occurs which a watcher is actively watching then the watcher generates a corresponding target event. Target events are only created by watchers. If several watchers are interested in the same source event then each will generate their own target event. Hence, any particular source event may result in zero, one, two, or any number of target events: the same as the number of watchers which were actively watching for it.
Target events are queued to be processed in priority order (priority being determined by the creating watcher) and in FIFO order among events of the same priority. Queued ("pending") events can, in some cases, be cancelled before being processed. A queued event is processed by being passed to the callback function (or method on a particular object or class) which was specified to the watcher.
A watcher, once created, operates autonomously without the Event user having to retain any reference to it. However, keeping a reference makes it possible to modify most of the watchers characteristics. A watcher can be switched between active and inactive states. When inactive, it does not generate target events.
Some types of source event are not reified as target events immediately. Signals received, for example, are counted initially. The counted signals are reified at certain execution points. Hence, signal events may be processed out of order, and if handled carelessly, on the wrong side of a state change in event handling. A useful way to view this is that occurrence of the source event is not actually the arrival of the signal but is triggered by the counting of the signal.
Reification can be forced when necessary. The schedule on which some other events are created is non-obvious. This is especially the case with watchers that watch for a condition rather than an event. In some cases, target events are generated on a schedule that depends on the operation of the event loop.
Download (0.24MB)
Added: 2007-06-06 License: Perl Artistic License Price:
872 downloads
Event::RPC 0.90
Event::RPC is a event based transparent Client/Server RPC framework. more>>
Event::RPC is a event based transparent Client/Server RPC framework.
SYNOPSIS
#-- Server Code
use Event::RPC::Server;
use My::TestModule;
my $server = Event::RPC::Server->new (
port => 5555,
classes => { "My::TestModule" => { ... } },
);
$server->start;
----------------------------------------------------------
#-- Client Code
use Event::RPC::Client;
my $client = Event::RPC::Client->new (
server => "localhost",
port => 5555,
);
$client->connect;
#-- Call methods of My::TestModule on the server
my $obj = My::TestModule->new ( foo => "bar" );
my $foo = $obj->get_foo;
ABSTRACT
Event::RPC supports you in developing Event based networking client/server applications with transparent object/method access from the client to the server. Network communication is optionally encrypted using IO::Socket::SSL. Several event loop managers are supported due to an extensible API. Currently Event and Glib are implemented.
<<lessSYNOPSIS
#-- Server Code
use Event::RPC::Server;
use My::TestModule;
my $server = Event::RPC::Server->new (
port => 5555,
classes => { "My::TestModule" => { ... } },
);
$server->start;
----------------------------------------------------------
#-- Client Code
use Event::RPC::Client;
my $client = Event::RPC::Client->new (
server => "localhost",
port => 5555,
);
$client->connect;
#-- Call methods of My::TestModule on the server
my $obj = My::TestModule->new ( foo => "bar" );
my $foo = $obj->get_foo;
ABSTRACT
Event::RPC supports you in developing Event based networking client/server applications with transparent object/method access from the client to the server. Network communication is optionally encrypted using IO::Socket::SSL. Several event loop managers are supported due to an extensible API. Currently Event and Glib are implemented.
Download (0.031MB)
Added: 2007-04-04 License: Perl Artistic License Price:
933 downloads
Open Geographic Datastore Interface 3.1.5
Open Geographic Datastore Interface is an API that uses a standardized access method to work in conjunction with GIS software. more>>
OGDI is the Open Geographic Datastore Interface. OGDI is an application programming interface (API) that uses a standardized access methods to work in conjunction with GIS software packages (the application) and various geospatial data products.
OGDI uses a client/server architecture to facilitate the dissemination of geospatial data products over any TCP/IP network, and a driver-oriented approach to facilitate access to several geospatial data products/formats.
Enhancements:
- This release fixes some significant bugs in the VRF (VPF) driver.
<<lessOGDI uses a client/server architecture to facilitate the dissemination of geospatial data products over any TCP/IP network, and a driver-oriented approach to facilitate access to several geospatial data products/formats.
Enhancements:
- This release fixes some significant bugs in the VRF (VPF) driver.
Download (0.89MB)
Added: 2005-06-29 License: Freely Distributable Price:
1579 downloads
Multi-Simulation Interface 0.14.0
Multi-Simulator Interface, in shrot MSI, is a simulation interconnection engine. more>>
Multi-Simulator Interface, in shrot MSI, is a simulation interconnection engine. In other words it is a program that connects simulations together by synchronizing their clocks and data. Multi-Simulation Interface serves the same purpose as HLA and supports most of HLAs functionality (and more).
The MSI is an HLA alternative. The major motivating factors in the design of the MSI are speed, interoperability, and ease of use.
The MSI was written as a cutting edge distributed simulation component to connect multiple instances of ATLs premiere simulation software, CSIM, and it can be used to interface any compatible simulations.
How does the MSI compare to HLA?
The MSI was originally created to be just a light weight HLA RTI. However, as it was written, limitations in HLA were discovered. The MSI is an improvement on both the design and implementation of HLA. Some highlights include:
A 1,536 to 1 reduction in size over the publicly available (until late 2002) HLA RTI.
At least one order of magnitude of bandwidth consumption less than the publicly available (until late 2002) HLA RTI.
The ability to subscribe to an object name in addition to a type.
Time synchronization that allows for proper causality when used with discrete event simulators.
Support for systems-of-systems (SoS) and hierarchically organized simulations.
Availability for many platforms.
MSI Concept - A Synchronized Data Broker
The concept behind MSI is the synchronized data broker. There are many connected software systems that posses state data that changes over the life of that system. In the case where these systems need to exchange this changing data with other systems and the other systems will exhibit the effects of this data on their own state, the synchronization of this data may need to be managed.
Historically the management of this data has been as simple as tagging it with the time of its release. If there is any conflict in the data the most recent version of the data is used. If the data is late an extrapolation can potentially be used. In SQL relational databases transactions and locking are used to ensure data integrity. Most data brokering services offer little or no sychronization, only delivery.
MSI Setup and Use
The MSI uses a XML stream through a direct socket connection for communications. This enables the MSI to be used from any programming language that can use sockets (C, C++, Java, Ada, Lisp, Perl, etc.). Also, the MSI was written with cross-platform libraries that make it portable to all the major OS platforms (Linux, Solaris, Mac OS X, Microsoft Windows, IRIX, HPUX, etc.).
The MSI is a single executable file and is distributed with example code for the simulator/federate side interface.
MSI Time Synchronization
The MSI time synchronizer can mix unconstrained with time constrained simulations. Each constrained simulation reports the time of the next event that will occur in that simulation/federate. This time may be artificially inflated to cause loose synchronization (less overhead but less guarantee of accuracy). The simulations/federates will advance to the announced time.
MSI Data Synchronization
The MSI implements a publish/subscribe data broker. The MSI is presently not validating, therefore it does not require a separate data format specification (like the HLA FOM). When data format validation is implemented, it will be an optional feature and not written in Lisp. This greatly reduces MSIs setup time. Also, not being locked to a predetermined data format allows for dynamic data types.
There are five commands associated with the MSI data broker: publish, subscribe, update, unsubscribe, destroy (destroy is not implemented yet). Simulations/federates may subscribe to object names in addition to object types. This allows simulations to subscribe to specific objects of a type without needing to receive updates of all objects of that type. The update command is both an incoming and outgoing command. When a simulation/federate receives an update command, it is expected to reflect the new values of that object.
The MSI has a very flexible publish and subscribe system. A federate may subscribe to an object type or an object name. In addition a federate may specify particular attributes of an object or object type. For example, if an object has attributes name, x, y, and z, a federate that only considers two dimensions may choose to subscribe only to name, x, and y.
The MSI also supports systems of systems and object hierarchy in simulations. A publishing federate may designate a parent object. Subscribers may then subscribe to the objects children.
MSI Messaging
The MSI allows simulations/federates to send messages (interactions in HLA) to each other. These messages can contain multiple attributes and be multicast to a specific group of simulations.
Recently Added Features
Removed external library dependencies to improve the portability and fragility of the MSI.
Added a better client library.
Improved documentation.
Enhancements:
- An XML parsing bug in the utilities library was fixed.
- The socket library was enhanced with more protocols, Win32 tricks, and the ability to key off of addresses as well as names.
- The --wait-for command line argument was added.
- Several internal bugs were fixed.
- More of the client library and the CSIM interface were flushed out.
- All standard functionality was tested.
<<lessThe MSI is an HLA alternative. The major motivating factors in the design of the MSI are speed, interoperability, and ease of use.
The MSI was written as a cutting edge distributed simulation component to connect multiple instances of ATLs premiere simulation software, CSIM, and it can be used to interface any compatible simulations.
How does the MSI compare to HLA?
The MSI was originally created to be just a light weight HLA RTI. However, as it was written, limitations in HLA were discovered. The MSI is an improvement on both the design and implementation of HLA. Some highlights include:
A 1,536 to 1 reduction in size over the publicly available (until late 2002) HLA RTI.
At least one order of magnitude of bandwidth consumption less than the publicly available (until late 2002) HLA RTI.
The ability to subscribe to an object name in addition to a type.
Time synchronization that allows for proper causality when used with discrete event simulators.
Support for systems-of-systems (SoS) and hierarchically organized simulations.
Availability for many platforms.
MSI Concept - A Synchronized Data Broker
The concept behind MSI is the synchronized data broker. There are many connected software systems that posses state data that changes over the life of that system. In the case where these systems need to exchange this changing data with other systems and the other systems will exhibit the effects of this data on their own state, the synchronization of this data may need to be managed.
Historically the management of this data has been as simple as tagging it with the time of its release. If there is any conflict in the data the most recent version of the data is used. If the data is late an extrapolation can potentially be used. In SQL relational databases transactions and locking are used to ensure data integrity. Most data brokering services offer little or no sychronization, only delivery.
MSI Setup and Use
The MSI uses a XML stream through a direct socket connection for communications. This enables the MSI to be used from any programming language that can use sockets (C, C++, Java, Ada, Lisp, Perl, etc.). Also, the MSI was written with cross-platform libraries that make it portable to all the major OS platforms (Linux, Solaris, Mac OS X, Microsoft Windows, IRIX, HPUX, etc.).
The MSI is a single executable file and is distributed with example code for the simulator/federate side interface.
MSI Time Synchronization
The MSI time synchronizer can mix unconstrained with time constrained simulations. Each constrained simulation reports the time of the next event that will occur in that simulation/federate. This time may be artificially inflated to cause loose synchronization (less overhead but less guarantee of accuracy). The simulations/federates will advance to the announced time.
MSI Data Synchronization
The MSI implements a publish/subscribe data broker. The MSI is presently not validating, therefore it does not require a separate data format specification (like the HLA FOM). When data format validation is implemented, it will be an optional feature and not written in Lisp. This greatly reduces MSIs setup time. Also, not being locked to a predetermined data format allows for dynamic data types.
There are five commands associated with the MSI data broker: publish, subscribe, update, unsubscribe, destroy (destroy is not implemented yet). Simulations/federates may subscribe to object names in addition to object types. This allows simulations to subscribe to specific objects of a type without needing to receive updates of all objects of that type. The update command is both an incoming and outgoing command. When a simulation/federate receives an update command, it is expected to reflect the new values of that object.
The MSI has a very flexible publish and subscribe system. A federate may subscribe to an object type or an object name. In addition a federate may specify particular attributes of an object or object type. For example, if an object has attributes name, x, y, and z, a federate that only considers two dimensions may choose to subscribe only to name, x, and y.
The MSI also supports systems of systems and object hierarchy in simulations. A publishing federate may designate a parent object. Subscribers may then subscribe to the objects children.
MSI Messaging
The MSI allows simulations/federates to send messages (interactions in HLA) to each other. These messages can contain multiple attributes and be multicast to a specific group of simulations.
Recently Added Features
Removed external library dependencies to improve the portability and fragility of the MSI.
Added a better client library.
Improved documentation.
Enhancements:
- An XML parsing bug in the utilities library was fixed.
- The socket library was enhanced with more protocols, Win32 tricks, and the ability to key off of addresses as well as names.
- The --wait-for command line argument was added.
- Several internal bugs were fixed.
- More of the client library and the CSIM interface were flushed out.
- All standard functionality was tested.
Download (3.0MB)
Added: 2006-05-26 License: GPL (GNU General Public License) Price:
1254 downloads
Python/Tk Empire Interface 1.18.1
Python/Tk Empire Interface project is a cross-platform Empire GUI client. more>>
Python/Tk Empire Interface project is a cross-platform Empire GUI client.
The Python/Tk Empire Interface (PTkEI) enables you to connect to empire 4.x.x (Wolfpack) servers.
Empire is a real-time war game with long tradition.
You can find out about Empire and currently running servers and other clients at its homepage.
This client is an example for a truly portable cross-platform GUI, known to run on Unix, X11, Win32 and Mac.
Additionally you do not give up any command line power as a player, but you have to to learn the empire commands to make use of this GUI client.
Main features:
- Portability
- Map Features
- Command Line
- Socket Interface
- Smart Features
<<lessThe Python/Tk Empire Interface (PTkEI) enables you to connect to empire 4.x.x (Wolfpack) servers.
Empire is a real-time war game with long tradition.
You can find out about Empire and currently running servers and other clients at its homepage.
This client is an example for a truly portable cross-platform GUI, known to run on Unix, X11, Win32 and Mac.
Additionally you do not give up any command line power as a player, but you have to to learn the empire commands to make use of this GUI client.
Main features:
- Portability
- Map Features
- Command Line
- Socket Interface
- Smart Features
Download (0.23MB)
Added: 2006-11-14 License: GPL (GNU General Public License) Price:
1076 downloads
General Package/Module Interface 0.7.1
General Package/Module Interface (GPMI) is a lightweight library that assists with modularizing applications. more>>
General Package/Module Interface (GPMI) is a lightweight library that assists with modularizing applications.
It includes prewritten script interpreter modules in addition to timers, events, and package dependencies.
Enhancements:
- This version features many bugfixes and memory leak cleanups.
- It is now possible to compile the code on Windows using mingw.
<<lessIt includes prewritten script interpreter modules in addition to timers, events, and package dependencies.
Enhancements:
- This version features many bugfixes and memory leak cleanups.
- It is now possible to compile the code on Windows using mingw.
Download (0.17MB)
Added: 2006-01-10 License: GPL (GNU General Public License) Price:
1384 downloads
Event::Stats 0.7
Event::Stats is a Perl module for event loop statistics. more>>
Event::Stats is a Perl module for event loop statistics. Instrument the Event module in order to gather statistics.
API
collect($yes)
Determines whether statistics are collected. Arithmetically adds $yes to the usage count. Stats are enabled while the usage count is positive.
$round_sec = round_seconds($sec)
Statistics are not collected in one second intervals. This function converts a *desired* time interval into an *available* time interval. Units are in seconds.
$elapse = total_time($sec)
Due to long-running callbacks, measurement intervals may take longer than expected. This function returns the actual clock-time for a given measurement interval.
($rans, $dies, $elapse) = idle_time($sec)
($runs, $dies, $elapse) = $watcher->stats($sec)
Return statistics for the last $sec seconds of operation. Three numbers are returned: the number of times the callback has been invoked, the number of uncaught exceptions and the number of seconds spent within the callback. Also see NetServer::ProcessTop.
enforce_max_callback_time($yes)
Useful for debugging. XXX
<<lessAPI
collect($yes)
Determines whether statistics are collected. Arithmetically adds $yes to the usage count. Stats are enabled while the usage count is positive.
$round_sec = round_seconds($sec)
Statistics are not collected in one second intervals. This function converts a *desired* time interval into an *available* time interval. Units are in seconds.
$elapse = total_time($sec)
Due to long-running callbacks, measurement intervals may take longer than expected. This function returns the actual clock-time for a given measurement interval.
($rans, $dies, $elapse) = idle_time($sec)
($runs, $dies, $elapse) = $watcher->stats($sec)
Return statistics for the last $sec seconds of operation. Three numbers are returned: the number of times the callback has been invoked, the number of uncaught exceptions and the number of seconds spent within the callback. Also see NetServer::ProcessTop.
enforce_max_callback_time($yes)
Useful for debugging. XXX
Download (0.005MB)
Added: 2007-04-04 License: Perl Artistic License Price:
933 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above event interface search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
