Result:
found more than 544 distributions - search limited to the first 2001 files matching your query
( run in 1.395 )
HTML-Tag
view release on metacpan or search on metacpan
If you are a web developer such as me, you know that many times you
needed to use html controls that are not directly available in the HTML
language.
Every time you needed of use a datetime input control or to validate an
input field you needed to mix html, javascript and cascade style sheet
to make what you want. And, in every project you needed that, you needed
to find all the required code for you "advanced" control or you must
reinvent the wheel.
This module try to encapsulate these advanced widget so that you can
HTML-Tidy
view release on metacpan or search on metacpan
if ( (rc >= 0 ) && configfile && *configfile ) {
rc = tidyLoadConfig( tdoc, configfile );
}
/* XXX I think this cascade is a bug waiting to happen */
if ( rc >= 0 ) {
rc = ( tidyOptSetValue( tdoc, TidyCharEncoding, "utf8" ) ? rc : -1 );
}
HTML-Tidy5
view release on metacpan or search on metacpan
if ( (rc >= 0 ) && configfile && *configfile ) {
rc = tidyLoadConfig( tdoc, configfile );
}
/* XXX I think this cascade is a bug waiting to happen */
if ( rc >= 0 ) {
rc = ( tidyOptSetValue( tdoc, TidyCharEncoding, "utf8" ) ? rc : -1 );
}
HTML-Valid
view release on metacpan or search on metacpan
tidy-html5.c view on Meta::CPAN
"accessibles, voir http://www.w3.org/WAI/GL et \n"
"http://www.html-tidy.org/Accessibility/"
},
{ TEXT_USING_LAYER, 0,
"Le mécanisme de positionnement au moyen des feuilles de style \n"
"en cascade (CSS) est préférable à l'élément propriétaire <LAYER>, \n"
"en raison du support limité des éditeurs pour LAYER.\n"
},
{ TEXT_USING_SPACER, 0,
"Il est recommandé d'utiliser les CSS pour contrôler les espacements \n"
"(par exemple pour le retrait, les marges et les interlignes).\n"
Handel-Storage-RDBO
view release on metacpan or search on metacpan
lib/Handel/Storage/RDBO/Result.pm view on Meta::CPAN
use Handel::Exception;
use Rose::DB::Object::Helpers;
};
sub delete {
return shift->storage_result->delete(cascade => 1, @_);
};
sub discard_changes {
return shift->storage_result->load(@_);
};
Harvey
view release on metacpan or search on metacpan
Word/noun.txt view on Meta::CPAN
cartwheel,cartwheels
carver,carvers
carving,carvings
cary,carys
caryatid,caryatids
cascade,cascades
case,cases
caseload,caseloads
casement,casements
cash,cashes
cashew,cashews
HiPi
view release on metacpan or search on metacpan
lib/HiPi/Constant.pm view on Meta::CPAN
# Mifare_One tag command word
MIFARE_REQIDL => 0x26, # find the antenna area does not enter hibernation
MIFARE_REQALL => 0x52, # find all the tags antenna area
MIFARE_ANTICOLL => 0x88, # anti-collision
MIFARE_CASCADE => 0x88, # cascade tag
MIFARE_SELECTTAG => 0x93, # selection tag
MIFARE_SELECT_CL1 => 0x93,
MIFARE_SELECT_CL2 => 0x95,
MIFARE_SELECT_CL3 => 0x97,
MIFARE_AUTHENT1A => 0x60, # authentication key A
Hopkins-Plugin-HMI
view release on metacpan or search on metacpan
share/root/static/yui/build/stylesheet/stylesheet-debug.js view on Meta::CPAN
return this;
},
/**
* <p>Unset style properties for a provided selector string, removing
* their effect from the style cascade.</p>
*
* <p>If the selector includes commas, it will be split into individual
* selectors and applied accordingly. If there are no properties
* remaining in the rule after unsetting, the rule is removed.</p>
*
IO-Lambda
view release on metacpan or search on metacpan
lib/IO/Lambda.pm view on Meta::CPAN
}
# propagate event destruction on all levels
sub destroy
{
shift-> cancel_all_events( cascade => 1);
}
# synchronisation
# drives objects dependant on the other objects until all of them
IO-SocketAlarm
view release on metacpan or search on metacpan
t/20-detect-event-eof.t view on Meta::CPAN
# repeat the test for TCP sockets
($s1, $s2)= tcp_socketpair;
is( collect_alarms($s1,$s2), ['ontime'], 'TCP alarms' );
# Set up a cascade of shutdowns
{
my @got_alarm;
local $SIG{ALRM}= sub { note "Got alarm early"; push @got_alarm, 'early' };
($s1, $s2)= tcp_socketpair;
t/20-detect-event-eof.t view on Meta::CPAN
# shutdown the final socket, triggering a chain reaction of shutdowns, and finally the signal
shutdown($seq[-3], SHUT_WR);
sleep 10; # sleep will get interrupted
ok( $seq[-1]->triggered, 'triggered' );
ok( $seq[-1]->finished, 'finished' );
is( \@got_alarm, ['ontime'], 'cascade ending with alarm' );
}
my $tcp_listen;
sub tcp_socketpair {
unless ($tcp_listen) {
IUP
view release on metacpan or search on metacpan
examples/1-apps/app-mdi.pl view on Meta::CPAN
my $self = shift;
$self->GetDialog->MDIARRANGE("TILEVERTICAL");
return IUP_DEFAULT;
}
sub mdi_cascade {
my $self = shift;
$self->GetDialog->MDIARRANGE("CASCADE");
return IUP_DEFAULT;
}
examples/1-apps/app-mdi.pl view on Meta::CPAN
),
IUP::Submenu->new( TITLE=>"Window", , child=>
IUP::Menu->new( name=>"winmenu", child=>[
IUP::Item->new( TITLE=>"Tile Horizontal", ACTION=>\&mdi_tilehoriz ),
IUP::Item->new( TITLE=>"Tile Vertical", ACTION=>\&mdi_tilevert ),
IUP::Item->new( TITLE=>"Cascade", ACTION=>\&mdi_cascade ),
IUP::Item->new( TITLE=>"Icon Arrange", ACTION=>\&mdi_icon ),
IUP::Item->new( TITLE=>"Close All", ACTION=>\&mdi_closeall ),
IUP::Separator->new(),
IUP::Item->new( TITLE=>"Next", ACTION=>\&mdi_next ),
IUP::Item->new( TITLE=>"Previous", ACTION=>\&mdi_previous ),
Icon-FamFamFam-Silk
view release on metacpan or search on metacpan
lib/Icon/FamFamFam/Silk.pm view on Meta::CPAN
accept=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAKfSURBVDjLpZPrS1NhHMf9O3bOdmwDCWREIYKEUHsVJBI7mg3FvCxL09290jZj2EyLMnJexkgpLbPUanNOberU5taUMnHZUULMvelCtWF0sW/n7MVMEiN64AsPD...
add=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJvSURBVDjLpZPrS5NhGIf9W7YvBYOkhlkoqCklWChv2WyKik7blnNris72bi6dus0DLZ0TDxW1odtopDs4D8MDZuLU0kXq61CijSIIasOvv94VTUfLiB74fXngup7n...
anchor=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAGdSURBVDjLpVMxa8JAFL6rAQUHXQoZpLU/oUOnDtKtW/MDBFHHThUKTgrqICgOEtd2EVxb2qFkKTgVChbSCnZTiVBEMBRLiEmafleCDaWxDX3w8e7dve+7l3cv1...
application=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAFiSURBVBgZpcEhbpRRGIXh99x7IU0asGBJWEIdCLaAqcFiCArFCkjA0KRJF0EF26kkFbVVdEj6/985zJ0wBjfp8ygJD6G3n358fP3m5NvtJscJYBObchEH...
application_add=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAH9SURBVDjLpZM9aFRREIW/ue9FF2IULDQuaYIGtTBRWGFJAgqSUsEmjZVgo4mFWBiwVVjBHwjGwsbCShExIAghoEUMARGNGFJYhIC7isXGRbORvJ0Z...
application_cascade=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAGeSURBVDjLjZLdKwRRGIf3X1wXuNAikiKfWXaVLO1SIjYlG9LYaGKxNSXWx1rnwoUo+Zhdu2vkRsp32ePCvH5nYoaGNaeemjkz5/ee85zX5W6V...
application_delete=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAH0SURBVBgZpcFPaM9xHMfx5/vz/Ywfv6ZwGC1mtRsXtRvFQSmlKK3JkRJymAul5EJcrFZrcnO0QpELDgrlKJcd5M9PtpHawew39v2+3y/7rlZuL...
application_double=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAGnSURBVDjLnZOxilNBGIW/mXt3CZsYQQtjJYqPkE4L8Q20WARbmxWEFQvBXrByQdDKF3CL1QcQH8DOKmVIkWIFbdybTe7M/x+Lm+zeFELcAz/Dw...
application_edit=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJRSURBVBgZpcHda81xHMDx9+d3fudYzuYw2RaZ5yTWolEiuZpCSjGJFEktUUr8A6ZxQZGHmDtqdrGUXHgoeZqSp1F2bLFWjtkOB8PZzvmd7+djv5X...
application_error=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAIiSURBVBgZpcE7SJZhFMDx/3neV/u8ZlhoVxAkESoyJYoa3BojDCFc25psaS8CWxoEhxAagiCpHCpqaa3AyiIISwjTtHIou3wX/b73nFOPIEG0SL...
application_form=>'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAFlSURBVBgZpcGxTpNhGIbh+20+DUkTRhkcNLBIOmG6+Q+egg4cgWExhDi5sDm5SErCoB4BDB4KjnVTBpooCTKUOvx9n4d+ISQOQNL0usI2i4hX7w7...
Image-CCV
view release on metacpan or search on metacpan
Inline_Stack_Vars;
Inline_Stack_Reset;
int i;
ccv_enable_default_cache();
ccv_dense_matrix_t* image = 0;
/* TODO: Make the cascade accessible from the outside */
ccv_bbf_classifier_cascade_t* cascade = ccv_bbf_read_classifier_cascade(training_data);
ccv_read(filename, &image, CCV_IO_GRAY | CCV_IO_ANY_FILE);
if (image != 0)
{
/* TODO: Make the BBF parameters accessible from the outside */
ccv_bbf_param_t params = { .interval = 5, .min_neighbors = 2, .accurate = 1, .flags = 0, .size = ccv_size(24, 24) };
ccv_array_t* seq = ccv_bbf_detect_objects(image, &cascade, 1, params);
for (i = 0; i < seq->rnum; i++)
{
ccv_comp_t* comp = (ccv_comp_t*)ccv_array_get(seq, i);
/* Create the new 5-item array */
AV* res = newAV();
Inline_Stack_Push(sv_2mortal(newRV_noinc((SV*) res)));
}
ccv_array_free(seq);
ccv_matrix_free(image);
}
ccv_bbf_classifier_cascade_free(cascade);
ccv_disable_cache();
Inline_Stack_Done;
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Image-Leptonica
view release on metacpan or search on metacpan
lib/Image/Leptonica/Func/binreduce.pm view on Meta::CPAN
Input: pixs (1 bpp)
level1, ... level 4 (thresholds, in the set {0, 1, 2, 3, 4})
Return: pixd, or null on error
Notes:
(1) This performs up to four cascaded 2x rank reductions.
(2) Use level = 0 to truncate the cascade.
=head1 AUTHOR
Zakariyya Mughal <zmughal@cpan.org>
Image-ObjectDetect
view release on metacpan or search on metacpan
eg/facedetect.pl view on Meta::CPAN
use Imager;
use Image::ObjectDetect;
Getopt::Long::Configure('bundling');
GetOptions(
'cascade=s' => \my $cascade,
'output=s' => \my $output,
'input=s' => \my $input,
'version|v' => \my $version,
'help|h' => \my $help,
);
if ($version) {
print "Image::ObjectDetect version $Image::ObjectDetect::VERSION\n";
exit;
}
pod2usage(0) if $help or !$cascade or !$output or !$input;
my $detector = Image::ObjectDetect->new($cascade);
my @faces = $detector->detect($input);
my $image = Imager->new->read(file => $input);
for my $face (@faces) {
$image->box(
xmin => $face->{x},
eg/facedetect.pl view on Meta::CPAN
=head1 SYNOPSIS
facedetect.pl [options]
Options:
-c -cascade cascade file
-o -output output filename
-i -input input filename
-v -version print version
-h -help print this help
Installer
view release on metacpan or search on metacpan
lib/Installer/cpanm.pm view on Meta::CPAN
$fatpacked{"App/cpanminus/Dependency.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'APP_CPANMINUS_DEPENDENCY';
package App::cpanminus::Dependency;use strict;use CPAN::Meta::Requirements;sub from_prereqs {my($class,$prereqs,$phases,$types)=@_;my@deps;for my$type (@$types){push@deps,$class->from_versions($prereqs->merged_requirements($phases,[$type])->as_stri...
APP_CPANMINUS_DEPENDENCY
$fatpacked{"App/cpanminus/script.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'APP_CPANMINUS_SCRIPT';
package App::cpanminus::script;use strict;use Config;use Cwd ();use App::cpanminus;use App::cpanminus::Dependency;use File::Basename ();use File::Find ();use File::Path ();use File::Spec ();use File::Copy ();use File::Temp ();use Getopt::Long ();us...
It appears your cpanm executable was installed via `perlbrew install-cpanm`.
cpanm --self-upgrade won't upgrade the version of cpanm you're running.
Run the following command to get it upgraded.
lib/Installer/cpanm.pm view on Meta::CPAN
A dialog will be prompted to confirm the files to be deleted. If you pass
C<-f> option as well, the dialog will be skipped and uninstallation
will be forced.
=item --cascade-search
B<EXPERIMENTAL>: Specifies whether to cascade search when you specify
multiple mirrors and a mirror doesn't have a module or has a lower
version of the module than requested. Defaults to false.
=item --skip-installed
Interchange6-Schema
view release on metacpan or search on metacpan
lib/Interchange6/Schema/Result/Address.pm view on Meta::CPAN
=cut
has_many
orderlines_shipping => "Interchange6::Schema::Result::OrderlinesShipping",
{ "foreign.addresses_id" => "self.addresses_id" },
{ cascade_copy => 0, cascade_delete => 0 };
=head2 orders
Type: has_many
lib/Interchange6/Schema/Result/Address.pm view on Meta::CPAN
=cut
has_many
orders => "Interchange6::Schema::Result::Order",
{ "foreign.billing_addresses_id" => "self.addresses_id" },
{ cascade_copy => 0, cascade_delete => 0 };
=head2 user
Type: belongs_to
JS-SourceMap
view release on metacpan or search on metacpan
t/fixtures/jquery.js view on Meta::CPAN
values[ index ] = jQuery._data( elem, "olddisplay" );
display = elem.style.display;
if ( show ) {
// Reset the inline display of this element to learn if it is
// being hidden by cascaded rules or not
if ( !values[ index ] && display === "none" ) {
elem.style.display = "";
}
// Set elements which have been overridden with display: none
JSON-Schema-AsType
view release on metacpan or search on metacpan
lib/JSON/Schema/AsType.pm view on Meta::CPAN
unless ( $url =~ m#^\w+://# ) { # doesn't look like an uri
my $id =$self->uri;
$id =~ s#[^/]*$##;
$url = $id . $url;
# such that the 'id's can cascade
if ( my $p = $self->parent_schema ) {
return $p->fetch( $url );
}
}
JavaScript-Duktape-XS
view release on metacpan or search on metacpan
*/
duk_fatal_function fatal_func;
/* Main list of allocated heap objects. Objects are either here,
* in finalize_list waiting for processing, or in refzero_list
* temporarily while a DECREF refzero cascade finishes.
*/
duk_heaphdr *heap_allocated;
/* Temporary work list for freeing a cascade of objects when a DECREF
* (or DECREF_NORZ) encounters a zero refcount. Using a work list
* allows fixed C stack size when refcounts go to zero for a chain of
* objects. Outside of DECREF this is always a NULL because DECREF is
* processed without side effects (only memory free calls).
*/
*
* List processing assumes refcounts are kept up-to-date at all times, so
* that once the finalizer returns, a zero refcount is a reliable reason to
* free the object immediately rather than place it back to the heap. This
* is the case because we run outside of refzero_list processing so that
* DECREF cascades are handled fully inline.
*
* For mark-and-sweep queued objects (had_zero_refcount false) the object
* may be freed immediately if its refcount is zero after the finalizer call
* (i.e. finalizer removed the reference loop for the object). If not, the
* next mark-and-sweep will collect the object unless it has become reachable
* the refcounts.
*
* Note that any of the DECREFs may cause a refcount to drop to zero. If so,
* the object won't be refzero processed inline, but will just be queued to
* refzero_list and processed by an earlier caller working on refzero_list,
* eliminating C recursion from even long refzero cascades. If refzero
* finalization is triggered by mark-and-sweep, refzero conditions are ignored
* (objects are not even queued to refzero_list) because mark-and-sweep deals
* with them; refcounts are still updated so that they remain in sync with
* actual references.
*/
* - When we're done with the current object, read its 'prev' pointer and
* free the object. If 'prev' is NULL, we've reached head of list and are
* done: set refzero_list to NULL and process pending finalizers. Otherwise
* continue processing the list.
*
* A refzero cascade is free of side effects because it only involves
* queueing more objects and freeing memory; finalizer execution is blocked
* in the code path queueing objects to finalize_list. As a result the
* initial refzero call (which triggers duk__refcount_free_pending()) must
* check finalize_list so that finalizers are executed snappily.
*
* If finalize_list processing starts first, refzero may occur while we're
* processing finalizers. That's fine: that particular refzero cascade is
* handled to completion without side effects. Once the cascade is complete,
* we'll run pending finalizers but notice that we're already doing that and
* return.
*
* This could be expanded to allow incremental freeing: just bail out
* early and resume at a future alloc/decref/refzero. However, if that
#endif
DUK_HEAP_INSERT_INTO_FINALIZE_LIST(heap, hdr);
/* Process finalizers unless skipping is explicitly
* requested (NORZ) or refzero_list is being processed
* (avoids side effects during a refzero cascade).
* If refzero_list is processed, the initial refzero
* call will run pending finalizers when refzero_list
* is done.
*/
if (!skip_free_pending && heap->refzero_list == NULL) {
heap->refzero_list = hdr;
if (root == NULL) {
/* Object is now queued. Refzero_list was NULL so
* no-one is currently processing it; do it here.
* With refzero processing just doing a cascade of
* free calls, we can process it directly even when
* NORZ macros are used: there are no side effects.
*/
duk__refcount_free_pending(heap);
DUK_ASSERT(heap->refzero_list == NULL);
/* Process finalizers only after the entire cascade
* is finished. In most cases there's nothing to
* finalize, so fast path check to avoid a call.
*/
#if defined(DUK_USE_FINALIZER_SUPPORT)
if (!skip_free_pending && DUK_UNLIKELY(heap->finalize_list != NULL)) {
/*
* Incref and decref functions.
*
* Decref may trigger immediate refzero handling, which may free and finalize
* an arbitrary number of objects (a "DECREF cascade").
*
* Refzero handling is skipped entirely if (1) mark-and-sweep is running or
* (2) execution is paused in the debugger. The objects are left in the heap,
* and will be freed by mark-and-sweep or eventual heap destruction.
*
*
* Also, a GC triggered during this reallocation process must not interfere
* with the object being resized. This is currently controlled by preventing
* finalizers (as they may affect ANY object) and object compaction in
* mark-and-sweep. It would suffice to protect only this particular object
* from compaction, however. DECREF refzero cascades are side effect free
* and OK.
*
* Note: because we need to potentially resize the valstack (as part
* of abandoning the array part), any tval pointers to the valstack
* will become invalid after this call.
}
DUK_DD(DUK_DDPRINT("-> throw not caught by current thread, yield error to resumer and recheck longjmp"));
/* Not caught by current thread, thread terminates (yield error to resumer);
* note that this may cause a cascade if the resumer terminates with an uncaught
* exception etc (this is OK, but needs careful testing).
*/
DUK_ASSERT(thr->resumer != NULL);
DUK_ASSERT(thr->resumer->callstack_top >= 2); /* ECMAScript activation + Duktape.Thread.resume() activation */
JavaScript-Duktape
view release on metacpan or search on metacpan
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
*/
duk_fatal_function fatal_func;
/* Main list of allocated heap objects. Objects are either here,
* in finalize_list waiting for processing, or in refzero_list
* temporarily while a DECREF refzero cascade finishes.
*/
duk_heaphdr *heap_allocated;
/* Temporary work list for freeing a cascade of objects when a DECREF
* (or DECREF_NORZ) encounters a zero refcount. Using a work list
* allows fixed C stack size when refcounts go to zero for a chain of
* objects. Outside of DECREF this is always a NULL because DECREF is
* processed without side effects (only memory free calls).
*/
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
*
* List processing assumes refcounts are kept up-to-date at all times, so
* that once the finalizer returns, a zero refcount is a reliable reason to
* free the object immediately rather than place it back to the heap. This
* is the case because we run outside of refzero_list processing so that
* DECREF cascades are handled fully inline.
*
* For mark-and-sweep queued objects (had_zero_refcount false) the object
* may be freed immediately if its refcount is zero after the finalizer call
* (i.e. finalizer removed the reference loop for the object). If not, the
* next mark-and-sweep will collect the object unless it has become reachable
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
* the refcounts.
*
* Note that any of the DECREFs may cause a refcount to drop to zero. If so,
* the object won't be refzero processed inline, but will just be queued to
* refzero_list and processed by an earlier caller working on refzero_list,
* eliminating C recursion from even long refzero cascades. If refzero
* finalization is triggered by mark-and-sweep, refzero conditions are ignored
* (objects are not even queued to refzero_list) because mark-and-sweep deals
* with them; refcounts are still updated so that they remain in sync with
* actual references.
*/
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
* - When we're done with the current object, read its 'prev' pointer and
* free the object. If 'prev' is NULL, we've reached head of list and are
* done: set refzero_list to NULL and process pending finalizers. Otherwise
* continue processing the list.
*
* A refzero cascade is free of side effects because it only involves
* queueing more objects and freeing memory; finalizer execution is blocked
* in the code path queueing objects to finalize_list. As a result the
* initial refzero call (which triggers duk__refcount_free_pending()) must
* check finalize_list so that finalizers are executed snappily.
*
* If finalize_list processing starts first, refzero may occur while we're
* processing finalizers. That's fine: that particular refzero cascade is
* handled to completion without side effects. Once the cascade is complete,
* we'll run pending finalizers but notice that we're already doing that and
* return.
*
* This could be expanded to allow incremental freeing: just bail out
* early and resume at a future alloc/decref/refzero. However, if that
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
#endif
DUK_HEAP_INSERT_INTO_FINALIZE_LIST(heap, hdr);
/* Process finalizers unless skipping is explicitly
* requested (NORZ) or refzero_list is being processed
* (avoids side effects during a refzero cascade).
* If refzero_list is processed, the initial refzero
* call will run pending finalizers when refzero_list
* is done.
*/
if (!skip_free_pending && heap->refzero_list == NULL) {
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
heap->refzero_list = hdr;
if (root == NULL) {
/* Object is now queued. Refzero_list was NULL so
* no-one is currently processing it; do it here.
* With refzero processing just doing a cascade of
* free calls, we can process it directly even when
* NORZ macros are used: there are no side effects.
*/
duk__refcount_free_pending(heap);
DUK_ASSERT(heap->refzero_list == NULL);
/* Process finalizers only after the entire cascade
* is finished. In most cases there's nothing to
* finalize, so fast path check to avoid a call.
*/
#if defined(DUK_USE_FINALIZER_SUPPORT)
if (!skip_free_pending && DUK_UNLIKELY(heap->finalize_list != NULL)) {
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
/*
* Incref and decref functions.
*
* Decref may trigger immediate refzero handling, which may free and finalize
* an arbitrary number of objects (a "DECREF cascade").
*
* Refzero handling is skipped entirely if (1) mark-and-sweep is running or
* (2) execution is paused in the debugger. The objects are left in the heap,
* and will be freed by mark-and-sweep or eventual heap destruction.
*
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
*
* Also, a GC triggered during this reallocation process must not interfere
* with the object being resized. This is currently controlled by preventing
* finalizers (as they may affect ANY object) and object compaction in
* mark-and-sweep. It would suffice to protect only this particular object
* from compaction, however. DECREF refzero cascades are side effect free
* and OK.
*
* Note: because we need to potentially resize the valstack (as part
* of abandoning the array part), any tval pointers to the valstack
* will become invalid after this call.
lib/JavaScript/Duktape/C/lib/duktape.c view on Meta::CPAN
}
DUK_DD(DUK_DDPRINT("-> throw not caught by current thread, yield error to resumer and recheck longjmp"));
/* Not caught by current thread, thread terminates (yield error to resumer);
* note that this may cause a cascade if the resumer terminates with an uncaught
* exception etc (this is OK, but needs careful testing).
*/
DUK_ASSERT(thr->resumer != NULL);
DUK_ASSERT(thr->resumer->callstack_top >= 2); /* ECMAScript activation + Duktape.Thread.resume() activation */
JavaScript-Embedded
view release on metacpan or search on metacpan
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
*/
duk_fatal_function fatal_func;
/* Main list of allocated heap objects. Objects are either here,
* in finalize_list waiting for processing, or in refzero_list
* temporarily while a DECREF refzero cascade finishes.
*/
duk_heaphdr *heap_allocated;
/* Temporary work list for freeing a cascade of objects when a DECREF
* (or DECREF_NORZ) encounters a zero refcount. Using a work list
* allows fixed C stack size when refcounts go to zero for a chain of
* objects. Outside of DECREF this is always a NULL because DECREF is
* processed without side effects (only memory free calls).
*/
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
*
* List processing assumes refcounts are kept up-to-date at all times, so
* that once the finalizer returns, a zero refcount is a reliable reason to
* free the object immediately rather than place it back to the heap. This
* is the case because we run outside of refzero_list processing so that
* DECREF cascades are handled fully inline.
*
* For mark-and-sweep queued objects (had_zero_refcount false) the object
* may be freed immediately if its refcount is zero after the finalizer call
* (i.e. finalizer removed the reference loop for the object). If not, the
* next mark-and-sweep will collect the object unless it has become reachable
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
* the refcounts.
*
* Note that any of the DECREFs may cause a refcount to drop to zero. If so,
* the object won't be refzero processed inline, but will just be queued to
* refzero_list and processed by an earlier caller working on refzero_list,
* eliminating C recursion from even long refzero cascades. If refzero
* finalization is triggered by mark-and-sweep, refzero conditions are ignored
* (objects are not even queued to refzero_list) because mark-and-sweep deals
* with them; refcounts are still updated so that they remain in sync with
* actual references.
*/
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
* - When we're done with the current object, read its 'prev' pointer and
* free the object. If 'prev' is NULL, we've reached head of list and are
* done: set refzero_list to NULL and process pending finalizers. Otherwise
* continue processing the list.
*
* A refzero cascade is free of side effects because it only involves
* queueing more objects and freeing memory; finalizer execution is blocked
* in the code path queueing objects to finalize_list. As a result the
* initial refzero call (which triggers duk__refcount_free_pending()) must
* check finalize_list so that finalizers are executed snappily.
*
* If finalize_list processing starts first, refzero may occur while we're
* processing finalizers. That's fine: that particular refzero cascade is
* handled to completion without side effects. Once the cascade is complete,
* we'll run pending finalizers but notice that we're already doing that and
* return.
*
* This could be expanded to allow incremental freeing: just bail out
* early and resume at a future alloc/decref/refzero. However, if that
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
#endif
DUK_HEAP_INSERT_INTO_FINALIZE_LIST(heap, hdr);
/* Process finalizers unless skipping is explicitly
* requested (NORZ) or refzero_list is being processed
* (avoids side effects during a refzero cascade).
* If refzero_list is processed, the initial refzero
* call will run pending finalizers when refzero_list
* is done.
*/
if (!skip_free_pending && heap->refzero_list == NULL) {
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
heap->refzero_list = hdr;
if (root == NULL) {
/* Object is now queued. Refzero_list was NULL so
* no-one is currently processing it; do it here.
* With refzero processing just doing a cascade of
* free calls, we can process it directly even when
* NORZ macros are used: there are no side effects.
*/
duk__refcount_free_pending(heap);
DUK_ASSERT(heap->refzero_list == NULL);
/* Process finalizers only after the entire cascade
* is finished. In most cases there's nothing to
* finalize, so fast path check to avoid a call.
*/
#if defined(DUK_USE_FINALIZER_SUPPORT)
if (!skip_free_pending && DUK_UNLIKELY(heap->finalize_list != NULL)) {
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
/*
* Incref and decref functions.
*
* Decref may trigger immediate refzero handling, which may free and finalize
* an arbitrary number of objects (a "DECREF cascade").
*
* Refzero handling is skipped entirely if (1) mark-and-sweep is running or
* (2) execution is paused in the debugger. The objects are left in the heap,
* and will be freed by mark-and-sweep or eventual heap destruction.
*
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
*
* Also, a GC triggered during this reallocation process must not interfere
* with the object being resized. This is currently controlled by preventing
* finalizers (as they may affect ANY object) and object compaction in
* mark-and-sweep. It would suffice to protect only this particular object
* from compaction, however. DECREF refzero cascades are side effect free
* and OK.
*
* Note: because we need to potentially resize the valstack (as part
* of abandoning the array part), any tval pointers to the valstack
* will become invalid after this call.
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
}
DUK_DD(DUK_DDPRINT("-> throw not caught by current thread, yield error to resumer and recheck longjmp"));
/* Not caught by current thread, thread terminates (yield error to resumer);
* note that this may cause a cascade if the resumer terminates with an uncaught
* exception etc (this is OK, but needs careful testing).
*/
DUK_ASSERT(thr->resumer != NULL);
DUK_ASSERT(thr->resumer->callstack_top >= 2); /* ECMAScript activation + Duktape.Thread.resume() activation */
JavaScript-ExtJS-V3
view release on metacpan or search on metacpan
share/ext-3.4.1/adapter/ext/ext-base-debug.js view on Meta::CPAN
* @type Boolean
*/
enableListenerCollection : false,
/**
* EXPERIMENTAL - True to cascade listener removal to child elements when an element is removed.
* Currently not optimized for performance.
* @type Boolean
*/
enableNestedListenerRemoval : false,
JavaScript-Packer
view release on metacpan or search on metacpan
t/scripts/s18.js view on Meta::CPAN
this._super( value );
this.element.attr( "aria-disabled", value );
// Support: IE8 Only
// #5332 / #6059 - opacity doesn't cascade to positioned elements in IE
// so we need to add the disabled class to the headers and panels
this._toggleClass( null, "ui-state-disabled", !!value );
this._toggleClass( this.headers.add( this.headers.next() ), null, "ui-state-disabled",
!!value );
},
Jifty-DBI
view release on metacpan or search on metacpan
t/02searches_joins.t view on Meta::CPAN
$users_obj->limit( alias => $groups_alias, column => 'name', value => 'Developers' );
#diag $users_obj->build_select_query;
is( $users_obj->count, 3, "three members" );
}
diag "cascaded LEFT JOIN optimization" if $ENV{'TEST_VERBOSE'};
{
$users_obj->clean_slate;
is_deeply( $users_obj, $clean_obj, 'after clean_slate looks like new object');
ok( !$users_obj->_is_joined, "new object isn't joined");
my $alias = $users_obj->join(
Jifty-Plugin-RecordHistory
view release on metacpan or search on metacpan
lib/Jifty/Plugin/RecordHistory.pm view on Meta::CPAN
When you're importing the mixin you have several options to control the behavior
of history. Here are the defaults:
use Jifty::Plugin::RecordHistory::Mixin::Model::RecordHistory (
cascaded_delete => 1,
delete_change => 0,
);
If C<cascaded_delete> is true, then
L<Jifty::Plugin::RecordHistory::Model::Change> and
L<Jifty::Plugin::RecordHistory::Model::ChangeField> records are deleted at the
same time the original record they refer to is deleted. If C<cascaded_delete>
is false, then the Change and ChangeField records persist even if the original
record is deleted.
If C<delete_change> is true, then when your record is deleted we create a
L<Jifty::Plugin::RecordHistory::Model::Change> record whose type is C<delete>.
If C<delete_change> is false, then we do not record the deletion. If
both C<cascaded_delete> I<and> C<delete_change> are true, then you will end up
with only one change after the record is deleted -- the C<delete>.
=head2 Grouping
By default, the only mechanism that groups together change_fields onto a single
Jifty
view release on metacpan or search on metacpan
lib/Jifty/Handler.pm view on Meta::CPAN
$static->add( Plack::App::File->new
( root => Jifty->config->framework('Web')->{DefaultStaticRoot} )->to_app );
# the buffering and unsetting of psgi.streaming is to vivify the
# responded res from the $static cascade app.
builder {
enable 'Plack::Middleware::ConditionalGET';
enable
sub { my $app = shift;
sub { my $env = shift;
Kevin-Command-kevin
view release on metacpan or search on metacpan
t/pg_worker.t view on Meta::CPAN
use Minion;
# Isolate tests
require Mojo::Pg;
my $pg = Mojo::Pg->new($ENV{TEST_ONLINE});
$pg->db->query('drop schema if exists minion_worker_test cascade');
$pg->db->query('create schema minion_worker_test');
my $minion = Minion->new(Pg => $ENV{TEST_ONLINE});
$minion->backend->pg->search_path(['minion_worker_test']);
# Basics
t/pg_worker.t view on Meta::CPAN
is_deeply $status->{queues}, ['default'], 'right structure';
is $status->{performed}, 1, 'right value';
ok $status->{repair_interval}, 'has a value';
# Clean up once we are done
$pg->db->query('drop schema minion_worker_test cascade');
done_testing();
KiokuDB-Backend-DBI
view release on metacpan or search on metacpan
lib/KiokuDB/Backend/DBI.pm view on Meta::CPAN
my $batch_size = $self->batch_size || scalar(@ids);
my @ids_copy = @ids;
while ( my @batch_ids = splice @ids_copy, 0, $batch_size ) {
if ( $self->extract ) {
# FIXME rely on cascade delete?
my $sth = $dbh->prepare_cached("DELETE FROM gin_index WHERE id IN (" . join(", ", ('?') x @batch_ids) . ")");
$sth->execute(@batch_ids);
$sth->finish;
}
Kossy
view release on metacpan or search on metacpan
lib/Kossy.pm view on Meta::CPAN
};
1;
## views/index.tx
: cascade base
: around content -> {
<: $greeting :>
: }
=head1 DESCRIPTION
( run in 1.395 second using v1.01-cache-2.11-cpan-49f99fa48dc )