Free callbacks software for linux

Channel is a generic/simple facility with the purpose of making event dispatching and message passing as straightforward to use as data structures:
Channel is a template library, with its major components configurable as template parameters:
template
<
class Id_Type,
class Id_Trait = IdTrait ,
class SynchPolicy = ACE_MT_SYNCH,
class AllocPolicy,
class Router = MapRouter
>
class Channel
By replacing Id_Type, Id_Trait and Router with various concrete classes, Channel can support table/linear message routing, hierarchical routing and associative routing (Linda style) at the demand of user. The same way, we can use integer, string, POD structs or any class as message ids (provided that proper operations are defined with Id_Trait)
Channel provides complete publish/subscribe interface for channel members (peer threads in message passing and objects in event dispatching) to pub/sub message/event ids/types and send/receive messages/events
Channels are process local entities which can be "connected" to allow transparent distributed communication between members in different channels (Connectors based on tcp socket and unix domain socket are provided as samples)
Namespace control:
The ids published/subscribed by channel members constitute channels namespace.
Channel provides publish/subscribe scope control; When ids are published/subscribed, peers can specify desired scope (LOCAL, REMOTE, GLOBAL)
When 2 channels are connected, their namespaces are automatically "merged", which is transparent to both channel members and programmers. Members can communicate with members in remote channels the same way as with local members (by pub/sub ids).
Namespace merge/integration is controlled by:
Id scope specification
filters and translators defined at channel connections
Channel communication are peer-2-peer; there are no central daemons required for message passing.
Channel support both asynchronous message passing and synchronous event dispatching models.
Channel is built on top of
ACE (Adaptive Communication Environment) to gain platform independence.
Enhancements:
- The framework was ported to Windows XP with VC8.
- Dispatching policy was added as a Channel template parameter to support various dispatching algorithms.
- Broadcast and simple RoundRobin dispatching policies were implemented for testing.
- Callback was changed to functor style so that normal functions and functors can be directly used as callbacks.

Trackballs is a FREE and simple game similar to the classic game Marble Madness.
By steering a marble through a track filled with vicious hammers, pools of acid, and other obstacles the player collects points.
When the ball reaches the destination, the player continue to the next, more difficult track - unless, of course, time runs out first.
Enhancements:
- This update includes new user contributed material (new songs and maps) as well as a number of new API functions and cleanups to make it easier and more flexible to design new levels.
- The built in map editor has some improvements (a few missing features have been added).
- Event callbacks on arbitrary animated objects and customizable score/time bonuses when killing arbitrary animated objects have been implemented.
- The documentation for the built-in scripting language has been rewritten.

XML_PullParser moves the API of the PHP XML facility from an event-based model to a token-based model.
Instead of processing data as it is passed from the parser to callbacks, a script using PullParser requests "tokens" from XML_PullParser_getToken() and a number of helper functions.
Tokens are arrays representing XML structures, which become available in the order in which they appear in the document being parsed. Methods are provided both to get tokens and to extract their data.
Enhancements:
- Fixed a bug in XML_PullParser_getText and enhanced its functionality with addition of a new parameter which enables more control over return value when this function is passed an array or tokenized array to be searched for data.
- Its behavior should now be fully consistent with extensivley updated documentation for the method.
- Also, updated and clarified documentation of several other methods and functions.

TclMilter is a package for Tcl (written in C) that implements an interface to SendMails Milter (Mail Filter) API for developing custom scripted message rewriting and spam filtering processes.
A thread-enabled Tcl build is required due to Milters threading requirements. However, you can only run, configure, or register callbacks for a milter from the first thread/interpreter the package is loaded into.
If you need to be able to stop the milter from within Tcl, you can load the package in another thread to do so. Only the "milter stop" command will function in secondary threads.
This extension is provided under the GNU General Public License (GPL) (see the file "license.terms" for details).
Main features:
- The smfi_opensocket command is not provided, only milter main as an interface to smfi_main.
- The smfi_setconn, smfi_settimeout, smfi_setbacklog and smfi_setdbg commands, as well as settings normally provided through smfi_main are instead provided as milter configure options.
- The smfi_register command is provided as milter register; however, unlike libmilter its possible to register and unregister callbacks at any time, rather than just once prior to calling main.
- There isnt a single data storage value for smfi_setpriv; rather, TclMilters milter setpriv command uses a hash table so you can set individual, custom variables with data to associate with a context.
- The context provided to callbacks is not simply a pointer, but is an actual Tcl command that can be used to interact with the context.

Libdnsres provides a non-blocking, thread-safe API for resolving DNS names. Libdnsres requires that your main application is built on top of libevent. The API essentially mirrors the traditional gethostbyname and getaddrinfo interfaces.

All return values have been replaced by callbacks instead. The code borrows heavily from the BSD resolver library. In fact, it is an extremely ugly hack to make the BSD resolver library non-blocking and thread-safe without changing the API too much.

Although it has not been tested heavily, it should compile on BSD systems and Linux. The library comes with a simple test program that can be use to verify if it works correctly.

Class::NiceApi is a Perl module that translates your methodNames to my method_names.

SYNOPSIS

use Class::NiceApi;

my $acl = Class::NiceApi->new( victim => Decision::ACL->new(), style => custom, table => { run_acl => RunACL } );

Perl method names should be written lowercased and multiple words should be connected via _. This is_good_coding_convention. Unfortunately this recommendation is ignored by many CPAN authors. Class::NiceApi helps pernickety programmers as me. It translates method names from isThisPerl to is_this_perl back and forth. Well, it so flexible it can translate allmost anything to anything. So it would translate perl_method_name to java programmers favorite perlMethodName.

METHODS

new()

Takes following parameters (which are also available as methods).

victim

An instance of a class where the method names subjected to translation.

style

A style is just a shortcut for the translation table. Following styles are currently supported: custom, with_underscore and to_lc.

[Note] They are implemented via a translating callback in $Class::NiceApi::callbacks. It filters the source method name and returns the destination name.

table

Here you can list explicit translations of method names, which are exceptions to the custom style filter.