callbacks results from the CPAN

lib/Class/Anonymous.pm view on Meta::CPAN


  my $subclass = extend $class, sub { my ($self) = @_; ... };

Define a new subclass of an existing anonymous class.
Takes an existing class and a code reference which will be called after the parent class builder callback(s).
Note that all callbacks receive the same arguments, so you might want to plan for that.

=head2 via

  my $subclass = extend $class, via { my ($self) = @_; ... };

view all matches for this distribution

Class-Autouse

2 results

lib/Class/Autouse.pm view on Meta::CPAN

}

sub _try_loaders {
	_debug(\@_, 0) if DEBUG;
	my ($class, $function, @optional_args) = @_;
	# The function and args are only present to help callbacks whose main goal is to
	# do "syntactic sugar" instead of really writing a class

	# This allows us to shortcut out of re-checking a class
	$TRIED_CLASS{$class}++;

lib/Class/Autouse.pm view on Meta::CPAN

several ways to do this in Perl.  Strategies which require overriding
UNIVERSAL::AUTOLOAD can use this interface instead to share that method
with the superloader, and with class gnerators.

When Perl is unable to find a subroutine/method, and all of the class loaders
are exhausted, callbacks registered via sugar() are called.  The callbacks
recieve the class name, method name, and parameters of the call.

If the callback returns nothing, Class::Autouse will continue to iterate through
other callbacks.  The first callback which returns a true value will
end iteration.  That value is expected to be a CODE reference which will respond
to the AUTOLOAD call.

Note: The sugar callback(s) will only be fired by UNIVERSAL::AUTOLOAD after all
other attempts at loading the class are done, and after attempts to use regular

view all matches for this distribution

Class-Constructor

1 match

t/lib/Test/Harness.pm view on Meta::CPAN


Remember exit code

Completely redo the print summary code.

Implement Straps callbacks.  (experimentally implemented)

Straps->analyze_file() not taint clean, don't know if it can be

Fix that damned VMS nit.

view all matches for this distribution

Class-Data-Annotated

1 match

lib/Class/Data/Annotated.pm view on Meta::CPAN

    my $$obj = Class::Data::Annotated->new();
    
=cut

our $VERSION = '0.2';
my $callbacks = {
                key_does_not_exist => sub {},
                index_does_not_exist => sub {},
                retrieve_index_from_non_array => sub {},
                retrieve_key_from_non_hash => sub {},
                };

lib/Class/Data/Annotated.pm view on Meta::CPAN

=cut

sub new {
    my ($class, $struct) = @_;
    croak('I just gotta have data') unless $struct;
    return bless {Annotations => Data::Annotated->new(), Data => Data::Path->new($struct, $callbacks)}, $class;
}

=head2 annotate($path, \%annotation)

annotate a peice of the data. if that piece does not exist it will return undef. Otherwise it returns the data annotated.

view all matches for this distribution

Class-InsideOut

1 match

Changes view on Meta::CPAN

0.14 Thu Mar 16 23:07:22 EST 2006

    - Fixed test bug where thread test wouldn't properly skip for Win32 Perl
      5.6 (with ithreads enabled for pseudofork but no threads.pm)
    
    - Improved handling of "die" in set_hook and get_hook callbacks

0.13 Fri Mar 10 10:32:08 EST 2006

    - Test for Scalar::Util::weaken fallback had a bug that would fail on
      Perl versions prior to 5.6.  Fixed to be fully backwards compatible.

view all matches for this distribution

Class-MakeMethods

2 results

MakeMethods.pm view on Meta::CPAN

in the most recent versions of Perl).

See L<perlref/"Making References">, point 4 for more information
on closures. (FWIW, I think there's a big opportunity for a "perlfunt"
podfile bundled with Perl in the tradition of "perlboot" and
"perltoot", exploring the utility of function references, callbacks,
closures, and continuations... There are a bunch of useful references
available, but not a good overview of how they all interact in a
Perlish way.)

view all matches for this distribution

Class-MethodMaker

9 results

lib/Class/MethodMaker.pm view on Meta::CPAN

per-class rather than per-instance data, L<-type>, to restrict the data stored
to certain types (e.g., objects of a certain class), L<-forward> to forward
(proxy) given methods onto components, L<-default>/L<-default_ctor> to set
default values for components, L<-tie_class> to tie the storage of a data type
to a given class, L<-read_cb>/L<-store_cb> to call user-defined functions on
read/store (without the overhead/complexity of ties; and allowing callbacks on
existing tie classes).

=head2 Detailed Use

C<Class::MethodMaker> installs I<components> into a class, by means of methods

lib/Class/MethodMaker.pm view on Meta::CPAN

  package main;
  my $m = MyClass->new;
  $m->scb1(4);
  my $n = $x->scb1; # 5

Generally, store callbacks are cheaper than read callbacks, because values are
read more often than they are stored.  But that is a generalization.  YMMV.

=back

=head1 EXPERIMENTAL & COMPATIBILITY notes

view all matches for this distribution

Class-Param

3 results

lib/Class/Param/Callback.pm view on Meta::CPAN


__END__

=head1 NAME

Class::Param::Callback - Param instance with callbacks

=head1 SYNOPSIS

    %store  = ();
    $param = Class::Param::Callback->new(

lib/Class/Param/Callback.pm view on Meta::CPAN

        remove => sub { return delete $store{ $_[1] }  }
    );

=head1 DESCRIPTION

Construct a params instance using callbacks.

=head1 METHODS

=over 4

view all matches for this distribution

Class-StateMachine

2 results

lib/Class/StateMachine.pm view on Meta::CPAN

  ...
  sub enter_state :OnState(angry) { shift->bark }
  sub enter_state :OnState(tired) { shift->lie_down }

The method C<on_leave_state> can also be used to register per-object
callbacks that are run just before changing the object state.

=head2 API

These are the methods available from Class::StateMachine:

lib/Class/StateMachine.pm view on Meta::CPAN

  $self->$callback(@args); # $callback is a method name

If the calling the C<leave_state> method is also defined, it is called first.

The method may be called repeatedly from the same state and the
callbacks will be executed in FIFO order.

=item $self->delay_until_next_state

=item $self->delay_until_next_state($method_name)

view all matches for this distribution

Class-Std-Slots

1 match

lib/Class/Std/Slots.pm view on Meta::CPAN

embed a reference to the progress bar in each instance of C<My::Downloader::Verbose>.

Instead we could extend C<My::Downloader::Better> to call an arbitrary callback via
a supplied code reference each time C<progress()> was called ... but then we have to
implement the interface that allows the callback to be defined. If we also want
notifications of retries and server failures we'll need still more callbacks. Tedious.

Or we could write C<My::Downloader::Lovely> like this:

    package My::Downloader::Lovely;
    use Class::Std;

lib/Class/Std/Slots.pm view on Meta::CPAN


    # Do the download with style
    $lovely->do_download();

We didn't have to subclass or modify C<My::Downloader::Lovely> and we didn't have to clutter its
interface with methods to allow callbacks to be installed.

Each signal can be connected to many slots simultaneously; perhaps we want some debug to show
up on the console too:

    use My::Downloader::Lovely;

view all matches for this distribution

Class-Trigger

1 match

MANIFEST view on Meta::CPAN

t/02_valid.t
t/03_inherit.t
t/04_object.t
t/05_args.t
t/06_coverage.t
t/07_abortable_callbacks.t
t/08_dollar_underscore.t
t/09_inherit.t
t/author-pod-syntax.t
t/lib/Foo.pm
t/lib/Foo/Bar.pm

view all matches for this distribution

Closure-Explicit

2 results

lib/Closure/Explicit.pm view on Meta::CPAN


=head1 SEE ALSO

=over 4

=item * L<curry> - provides a convenient interface for creating callbacks

=item * L<PadWalker> - does most of the real work behind this module

=item * L<Test::RefCount> - convenient testing for reference counts, makes
cycles easier to detect in test code

view all matches for this distribution

Cloudinary

4 results

Cloudinary-0.16/Cloudinary-0.16/lib/Cloudinary.pm view on Meta::CPAN


=item * A URL

=back

C<res> in callbacks will be the JSON response from L<http://cloudinary.com>
as a hash ref. It may also be C<undef> if something went wrong with the
actual HTTP POST.

See also L<https://cloudinary.com/documentation/upload_images> and
L<http://cloudinary.com/documentation/upload_images#raw_uploads>.

view all matches for this distribution

Clownfish-CFC

3 results

CHANGES view on Meta::CPAN

    * [CLOWNFISH-11] - Rework ByteBuf
    * [CLOWNFISH-15] - Method OFFSET vars should be uint32_t instead of
                       size_t
    * [CLOWNFISH-27] - Use functions rather than methods for refcounting
    * [CLOWNFISH-29] - Use PERL_NO_GET_CONTEXT
    * [CLOWNFISH-30] - Eliminate autogenerated "callbacks.h"
    * [CLOWNFISH-34] - String-only keys for LFReg
    * [CLOWNFISH-35] - Use size_t for Array and Hash indices
    * [CLOWNFISH-39] - Public Vector API
    * [CLOWNFISH-40] - LockFreeRegistry should be private
    * [CLOWNFISH-42] - Move NumberUtils to Lucy

view all matches for this distribution

Clownfish

1 match

CHANGES view on Meta::CPAN

    * [CLOWNFISH-11] - Rework ByteBuf
    * [CLOWNFISH-15] - Method OFFSET vars should be uint32_t instead of
                       size_t
    * [CLOWNFISH-27] - Use functions rather than methods for refcounting
    * [CLOWNFISH-29] - Use PERL_NO_GET_CONTEXT
    * [CLOWNFISH-30] - Eliminate autogenerated "callbacks.h"
    * [CLOWNFISH-34] - String-only keys for LFReg
    * [CLOWNFISH-35] - Use size_t for Array and Hash indices
    * [CLOWNFISH-39] - Public Vector API
    * [CLOWNFISH-40] - LockFreeRegistry should be private
    * [CLOWNFISH-42] - Move NumberUtils to Lucy

view all matches for this distribution

Clustericious-Admin

1 match

xt/author/pod_spelling_system.t view on Meta::CPAN

TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP

view all matches for this distribution

Clustericious-Coder-BSON

1 match

xt/release/pod_spelling_system.t view on Meta::CPAN

TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP

view all matches for this distribution

Clustericious

2 results

lib/Clustericious/Client.pm view on Meta::CPAN

    }

    $url = Mojo::URL->new($url) unless ref $url;
    my $parameters = $url->query;

    # Set up mappings from parameter names to modifier callbacks.
    my %url_modifier;
    my %payload_modifer;
    my %gen_url_modifier = (
        query  => sub { my $name = shift;
            sub { my ($u,$v) = @_; $u->query({$name => $v}) }  },

view all matches for this distribution

Cocoa-BatteryInfo

2 results

lib/Cocoa/BatteryInfo.pm view on Meta::CPAN


=head1 NOTICE

Callbacks listed above do nothing without under the Cocoa's event loop.

To work those callbacks correctly, you have to use this module with L<Cocoa::EventLoop>:

    use Cocoa::EventLoop;
    use Cocoa::BatteryInfo;
    
    Cocoa::BatteryInfo::low_battery_handler {

view all matches for this distribution

Cocoa-Growl

4 results

lib/Cocoa/Growl.pm view on Meta::CPAN


=back

=head3 CALLBACK NOTICE

You should run Cocoa's event loop NSRunLoop to be enable callbacks.
Simplest way to do that is use this module with L<Cocoa::EventLoop>.

    use Cocoa::EventLoop;
    use Cocoa::Growl ':all';

view all matches for this distribution

Cocoa-NetworkChange

1 match

src/Reachability.m view on Meta::CPAN

        NSLog(@"SCNetworkReachabilitySetDispatchQueue() failed: %s", SCErrorString(SCError()));
#endif

        //UH OH - FAILURE!
        
        // first stop any callbacks!
        SCNetworkReachabilitySetCallback(self.reachabilityRef, NULL, NULL);
        
        // then clear out the dispatch queue
        if(self.reachabilitySerialQueue)
        {

src/Reachability.m view on Meta::CPAN

    return YES;
}

-(void)stopNotifier
{
    // first stop any callbacks!
    SCNetworkReachabilitySetCallback(self.reachabilityRef, NULL, NULL);
    
    // unregister target from the GCD serial dispatch queue
    SCNetworkReachabilitySetDispatchQueue(self.reachabilityRef, NULL);

view all matches for this distribution

Code-Splice

1 match

lib/Code/Splice.pm view on Meta::CPAN

code to be modified.
The C<code> argument is required as it specifies the code to be spliced in.
That same code block should not be used for anything else under penalty of coredump.

The rest of the argumets specify where the code is to be inserted.  
Any number of C<precondition> and C<postcondition> arguments provide callbacks
to help locate the exact area to splice the code in at.
Before the code can e spliced in, all of the C<precondition> blocks must have returned
true, and none of the C<postcondition> blocks may have yet returned true.
If a C<postcondition> returns true before all of the C<precondition> blocks have,
an error is raised.

view all matches for this distribution

Code-TidyAll

5 results

php/PHP_CodeSniffer/src/Standards/Generic/Tests/WhiteSpace/ScopeIndentUnitTest.1.js view on Meta::CPAN

    script.onreadystatechange = null;
    callback.call(this);

};

this.callbacks[type] = {
    namespaces: {},
others: []
};

blah = function()

view all matches for this distribution

Cog

4 results

		firingStart,
		// Actual callback list
		list = [],
		// Stack of fire calls for repeatable lists
		stack = !options.once && [],
		// Fire callbacks
		fire = function( data ) {
			memory = options.memory && data;
			fired = true;
			firingIndex = firingStart || 0;
			firingStart = 0;

				}
			}
		},
		// Actual Callbacks object
		self = {
			// Add a callback or a collection of callbacks to the list
			add: function() {
				if ( list ) {
					// First, we save the current length
					var start = list.length;
					(function add( args ) {

								// Inspect recursively
								add( arg );
							}
						});
					})( arguments );
					// Do we need to add the callbacks to the
					// current firing batch?
					if ( firing ) {
						firingLength = list.length;
					// With memory, if we're not firing then
					// we should call right away

					});
				}
				return this;
			},
			// Check if a given callback is in the list.
			// If no argument is given, return whether or not list has callbacks attached.
			has: function( fn ) {
				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
			},
			// Remove all callbacks from the list
			empty: function() {
				list = [];
				firingLength = 0;
				return this;
			},

			},
			// Is it locked?
			locked: function() {
				return !stack;
			},
			// Call all callbacks with the given context and arguments
			fireWith: function( context, args ) {
				if ( list && ( !fired || stack ) ) {
					args = args || [];
					args = [ context, args.slice ? args.slice() : args ];
					if ( firing ) {

						fire( args );
					}
				}
				return this;
			},
			// Call all the callbacks with the given arguments
			fire: function() {
				self.fireWith( this, arguments );
				return this;
			},
			// To know if the callbacks have already been called at least once
			fired: function() {
				return !!fired;
			}
		};

			anim: animation,
			queue: animation.opts.queue
		})
	);

	// attach callbacks from options
	return animation.progress( animation.opts.progress )
		.done( animation.opts.done, animation.opts.complete )
		.fail( animation.opts.fail )
		.always( animation.opts.always );
}

					timers.splice( index, 1 );
				}
			}

			// start the next in the queue if the last step wasn't forced
			// timers currently will call their complete callbacks, which will dequeue
			// but only if they were gotoEnd
			if ( dequeue || !gotoEnd ) {
				jQuery.dequeue( this, type );
			}
		});

				jQuery( callbackContext ) :
				jQuery.event,
			// Deferreds
			deferred = jQuery.Deferred(),
			completeDeferred = jQuery.Callbacks("once memory"),
			// Status-dependent callbacks
			statusCode = s.statusCode || {},
			// Headers (they are sent all at once)
			requestHeaders = {},
			requestHeadersNames = {},
			// The jqXHR state

						s.mimeType = type;
					}
					return this;
				},

				// Status-dependent callbacks
				statusCode: function( map ) {
					var code;
					if ( map ) {
						if ( state < 2 ) {
							for ( code in map ) {
								// Lazy-add the new callback in a way that preserves old ones
								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
							}
						} else {
							// Execute the appropriate callbacks
							jqXHR.always( map[ jqXHR.status ] );
						}
					}
					return this;
				},

		}

		// aborting is no longer a cancellation
		strAbort = "abort";

		// Install callbacks on deferreds
		for ( i in { success: 1, error: 1, complete: 1 } ) {
			jqXHR[ i ]( s[ i ] );
		}

		// Get transport

				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
			} else {
				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
			}

			// Status-dependent callbacks
			jqXHR.statusCode( statusCode );
			statusCode = undefined;

			if ( fireGlobals ) {
				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",

					} else if ( xhr.readyState === 4 ) {
						// (IE6 & IE7) if it's in cache and has been
						// retrieved directly we need to fire the callback
						setTimeout( callback );
					} else {
						// Add to the list of active xhr callbacks
						xhr.onreadystatechange = xhrCallbacks[ id ] = callback;
					}
				},

				abort: function() {

		this[ callback ] = true;
		return callback;
	}
});

// Detect, normalize options and install callbacks for jsonp requests
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {

	var callbackName, overwritten, responseContainer,
		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
			"url" :

view all matches for this distribution

Cogwheel

1 match

MANIFEST view on Meta::CPAN

inc/Module/Install/Include.pm
inc/Module/Install/Makefile.pm
inc/Module/Install/Metadata.pm
inc/Module/Install/Win32.pm
inc/Module/Install/WriteAll.pm
lab/03_callbacks.t
lib/Cogwheel.pm
lib/Cogwheel/Client.pm
lib/Cogwheel/Object.pm
lib/Cogwheel/Plugin.pm
lib/Cogwheel/Role/Logging.pm

view all matches for this distribution

Compress-Deflate7

1 match

7zip/DOC/lzma.txt view on Meta::CPAN

better compression speed. Note that Windows has bad implementation for 
Large RAM Pages. 
It's OK to use same allocator for alloc and allocBig.


Single-call Compression with callbacks
--------------------------------------

Check C/LzmaUtil/LzmaUtil.c as example, 

When to use: file->file decompressing

7zip/DOC/lzma.txt view on Meta::CPAN



Single-call RAM->RAM Compression
--------------------------------

Single-call RAM->RAM Compression is similar to Compression with callbacks,
but you provide pointers to buffers instead of pointers to stream callbacks:

HRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
    CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark, 
    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);

view all matches for this distribution

Compress-Stream-Zstd

2 results

ext/zstd/contrib/seekable_format/zstd_seekable.h view on Meta::CPAN

*    - ZSTD_seekable_initFile() : A simplified file API using stdio.  fread and
*      fseek will be used to access the required data for building the seek
*      table and doing decompression operations.  `src` should not be closed
*      or modified until the ZSTD_seekable object is freed or reset.
*    - ZSTD_seekable_initAdvanced() : A general API allowing the client to
*      provide its own read and seek callbacks.
*        + ZSTD_seekable_read() : read exactly `n` bytes into `buffer`.
*                                 Premature EOF should be treated as an error.
*        + ZSTD_seekable_seek() : seek the read head to `offset` from `origin`,
*                                 where origin is either SEEK_SET (beginning of
*                                 file), or SEEK_END (end of file).

view all matches for this distribution

Compress-Zstd

2 results

ext/zstd/contrib/seekable_format/zstd_seekable.h view on Meta::CPAN

*    - ZSTD_seekable_initFile() : A simplified file API using stdio.  fread and
*      fseek will be used to access the required data for building the seek
*      table and doing decompression operations.  `src` should not be closed
*      or modified until the ZSTD_seekable object is freed or reset.
*    - ZSTD_seekable_initAdvanced() : A general API allowing the client to
*      provide its own read and seek callbacks.
*        + ZSTD_seekable_read() : read exactly `n` bytes into `buffer`.
*                                 Premature EOF should be treated as an error.
*        + ZSTD_seekable_seek() : seek the read head to `offset` from `origin`,
*                                 where origin is either SEEK_SET (beginning of
*                                 file), or SEEK_END (end of file).

view all matches for this distribution

Config-AST

1 match

lib/Config/AST.pm view on Meta::CPAN

is a CODE reference, it will be invoked as a method each time the value is
accessed.

Default values must be pure Perl values (not the values that should appear
in the configuration file). They are not processed using the B<check>
callbacks (see below).    
    
=item array => 0 | 1

If B<1>, the value of the setting is an array.  Each subsequent occurrence
of the statement appends its value to the end of the array.

view all matches for this distribution

Config-AutoConf

2 results


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.
Given callbacks for I<action_on_symbol_true> or I<action_on_symbol_false> are
called for each symbol checked using L</check_decl> receiving the symbol as
first argument.

=cut

ac_cv_func_FUNCTION variable.

If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
If any of I<action_on_cache_true>, I<action_on_cache_false> is defined,
both callbacks are passed to L</check_cached> as I<action_on_true> or
I<action_on_false> to C<check_cached>, respectively.

Returns: True if the function was found, false otherwise

=cut

function that was found.

If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
If any of I<action_on_cache_true>, I<action_on_cache_false> is defined,
both callbacks are passed to L</check_cached> as I<action_on_true> or
I<action_on_false> to C<check_cached>, respectively.  Given callbacks
for I<action_on_function_true> or I<action_on_function_false> are called for
each symbol checked using L</check_func> receiving the symbol as first
argument.

=cut

in the ac_cv_builtin_FUNCTION variable.

If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
If any of I<action_on_cache_true>, I<action_on_cache_false> is defined,
both callbacks are passed to L</check_cached> as I<action_on_true> or
I<action_on_false> to C<check_cached>, respectively.

Returns: True if the function was found, false otherwise

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.
Given callbacks for I<action_on_type_true> or I<action_on_type_false> are
called for each symbol checked using L</check_type> receiving the symbol as
first argument.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.
Given callbacks for I<action_on_size_true> or I<action_on_size_false> are
called for each symbol checked using L</check_sizeof_type> receiving the
symbol as first argument.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.
Given callbacks for I<action_on_align_true> or I<action_on_align_false> are
called for each symbol checked using L</check_alignof_type> receiving the
symbol as first argument.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be favored
over C<default includes> (represented by L</_default_includes>). If any of
I<action_on_cache_true>, I<action_on_cache_false> is defined, both callbacks
are passed to L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.
Given callbacks for I<action_on_member_true> or I<action_on_member_false> are
called for each symbol checked using L</check_member> receiving the symbol as
first argument.

=cut


If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
When a I<prologue> exists in the optional hash at end, it will be prepended
to the tested header. If any of I<action_on_cache_true>,
I<action_on_cache_false> is defined, both callbacks are passed to
L</check_cached> as I<action_on_true> or I<action_on_false> to
C<check_cached>, respectively.

=cut

If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
Each of existing key/value pairs using I<prologue>, I<action_on_cache_true>
or I<action_on_cache_false> as key are passed-through to each call of
L</check_header>.
Given callbacks for I<action_on_header_true> or I<action_on_header_false> are
called for each symbol checked using L</check_header> receiving the symbol as
first argument.

=cut

Each of existing key/value pairs using I<prologue>, I<action_on_header_true>
(as I<action_on_true> having the name of the tested header as first argument)
or I<action_on_header_false> (as I<action_on_false> having the name of the
tested header as first argument) as key are passed-through to each call of
L</_check_header>.
Given callbacks for I<action_on_cache_true> or I<action_on_cache_false> are
passed to the call of L</check_cached>.

=cut

sub _have_dirent_header_define_name

This method caches its result in the C<ac_cv_lib_>lib_func variable.

If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
If any of I<action_on_cache_true>, I<action_on_cache_false> is defined,
both callbacks are passed to L</check_cached> as I<action_on_true> or
I<action_on_false> to C<check_cached>, respectively.

It's recommended to use L<search_libs> instead of check_lib these days.

=cut

that needs to be prepended to LIBS.

If the very last parameter contains a hash reference, C<CODE> references
to I<action_on_true> or I<action_on_false> are executed, respectively.
If any of I<action_on_cache_true>, I<action_on_cache_false> is defined,
both callbacks are passed to L</check_cached> as I<action_on_true> or
I<action_on_false> to C<check_cached>, respectively.  Given callbacks
for I<action_on_lib_true> or I<action_on_lib_false> are called for
each library checked using L</link_if_else> receiving the library as
first argument and all C<@other_libs> subsequently.

=cut

functions as first argument), I<action_on_func_lib_true> (as
I<action_on_lib_true> having the name of the tested functions as first
argument), I<action_on_func_lib_false> (as I<action_on_lib_false> having
the name of the tested functions as first argument) as key are passed-
through to each call of L</search_libs>.
Given callbacks for I<action_on_lib_true>, I<action_on_lib_false>,
I<action_on_cache_true> or I<action_on_cache_false> are passed to the
call of L</search_libs>.

B<Note> that I<action_on_lib_true> and I<action_on_func_lib_true> or
I<action_on_lib_false> and I<action_on_func_lib_false> cannot be used