Result:
found more than 602 distributions - search limited to the first 2001 files matching your query
( run in 2.495 )
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
JQ-Lite
view release on metacpan or search on metacpan
lib/JQ/Lite.pm view on Meta::CPAN
=over 4
=item * C<if CONDITION then FILTER [elif CONDITION then FILTER ...] [else FILTER] end> for jq-style branching.
Evaluates conditions as filters against the current input. The first truthy branch emits its result; optional C<elif> clauses cascade additional tests, and the optional C<else> filter only runs when no prior branch matches. Without an C<else> clause ...
Example:
if .score >= 90 then "A"
elif .score >= 80 then "B"
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
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
LRU-Cache
view release on metacpan or search on metacpan
0.05 2026-04-27
- Fix t/007-map-grep.t on Perl 5.8.x: replace `// "UNDEF"`
(defined-or, 5.10+) with an explicit `defined(...) ? ... : ...`
form so the test parses on 5.8 (where // is regex match,
which cascaded into "Global symbol requires explicit package
name" errors at later lines and failed the whole file).
- Fix Perl_custom_op_register fallback in xop_compat.h for
pre-5.14 Perls: replace the broken fixed-arity macro with a
real function whose signature matches native 5.14+; the
C compiler then handles aTHX_ expansion at the call site.
LaTeX-PGF-Diagram2D
view release on metacpan or search on metacpan
doc-src/diagram-en.tex view on Meta::CPAN
for a distance of 0,1 (lines 22 and 23).
The \textit{axis()\/} method of the diagram object returns a reference
for an axis object. A number of axis object methods is used to
set up the axis. Each of the methods returns the axis object reference,
so the methods can be cascaded.
The \textit{plot()\/} method of the diagram object creates a new
plot object and returns the reference to it (line 23).
The \textit{set\textunderscore{}xy\textunderscore{}fct()\/} method
configures the plot object to use the \textit{I()\/} to calculate
LaTeXML-Plugin-LtxMojo
view release on metacpan or search on metacpan
lib/LaTeXML/Plugin/LtxMojo/public/js/external/ace-min/mode-pgsql.js view on Meta::CPAN
define("ace/mode/pgsql",["require","exports","module","ace/lib/oop","ace/mode/text","ace/tokenizer","ace/mode/pgsql_highlight_rules","ace/range"],function(e,t,n){var r=e("../lib/oop"),i=e("../mode/text").Mode,s=e("../tokenizer").Tokenizer,o=e("./pgsq...
LaTeXML
view release on metacpan or search on metacpan
lib/LaTeXML/Package/TeX.pool.ltxml view on Meta::CPAN
$token = shift(@toks);
$gullet->unread(@toks); }
$token; },
undigested => 1);
# Stub register for misdefinitions, to avoid a cascade of Errors.
DefRegisterI('\lx@DUMMY@REGISTER', undef, Tokens());
# Read a variable, ie. a token (after expansion) that is a writable register.
DefParameterType('Variable', sub {
my ($gullet) = @_;
Language-Haskell
view release on metacpan or search on metacpan
hugs98-Nov2003/fptools/libraries/GLUT/Graphics/UI/GLUT.hs view on Meta::CPAN
-- * /Stereo:/ A frame buffer capability providing left and right color buffers
-- for creating stereoscopic renderings. Typically, the user wears LCD
-- shuttered goggles synchronized with the alternating display on the screen
-- of the left and right color buffers.
--
-- * /Sub-menu:/ A menu cascaded from some sub-menu trigger.
--
-- * /Sub-menu trigger:/ A menu item that the user can enter to cascade another
-- pop-up menu.
--
-- * /Subwindow:/ A type of window that is the child window of a top-level
-- window or other subwindow. The drawing and visible region of a subwindow
-- is limited by its parent window.
Launcher-Cascade
view release on metacpan or search on metacpan
lib/Launcher/Cascade/Container.pm view on Meta::CPAN
package Launcher::Cascade::Container;
=head1 NAME
Launcher::Cascade::Container - a class to run L::C::Base launchers in cascade
=head1 SYNOPSIS
use Launcher::Cascade::Base::...;
use Launcher::Cascade::Container;
Lemonldap-NG-Manager
view release on metacpan or search on metacpan
site/htdocs/static/bwr/angular-animate/angular-animate.js view on Meta::CPAN
animationPaused = false;
close();
}
};
// checking the stagger duration prevents an accidentally cascade of the CSS delay style
// being inherited from the parent. If the transition duration is zero then we can safely
// rely that the delay value is an intentional stagger delay style.
var maxStagger = itemIndex > 0
&& ((timings.transitionDuration && stagger.transitionDuration === 0) ||
(timings.animationDuration && stagger.animationDuration === 0))
Lemonldap-NG-Portal
view release on metacpan or search on metacpan
site/htdocs/static/common/favicon.ico
site/htdocs/static/common/fi.png
site/htdocs/static/common/fonts/password.ttf
site/htdocs/static/common/fr.png
site/htdocs/static/common/he.png
site/htdocs/static/common/icons/application_cascade.png
site/htdocs/static/common/icons/arrow_refresh.png
site/htdocs/static/common/icons/calendar.png
site/htdocs/static/common/icons/comments.png
site/htdocs/static/common/icons/decryptValue.png
site/htdocs/static/common/icons/door_out.png
License-SPDX
view release on metacpan or search on metacpan
share/exceptions.json view on Meta::CPAN
"detailsUrl": "https://spdx.org/licenses/OCCT-exception-1.0.json",
"referenceNumber": 67,
"name": "Open CASCADE Exception 1.0",
"licenseExceptionId": "OCCT-exception-1.0",
"seeAlso": [
"http://www.opencascade.com/content/licensing"
]
},
{
"reference": "https://spdx.org/licenses/OpenJDK-assembly-exception-1.0.html",
"isDeprecatedLicenseId": false,
Lingua-Align
view release on metacpan or search on metacpan
lib/Lingua/Align/LinkSearch.pm view on Meta::CPAN
intersection ........... intersection between src2trg and trg2src
NTfirst ................ align non-terminals nodes first
NTonly ................. align only non-terminals
Tonly .................. align only termnal nodes
PaCoMT ................. used in PaCoMT project
cascaded ............... conbine search strategies (sequentially)
=cut
use 5.005;
use strict;
lib/Lingua/Align/LinkSearch.pm view on Meta::CPAN
my %attr=@_;
# my $type = $attr{-link_search} || 'greedy';
my $type = $attr{-link_search} || 'threshold';
if ($type=~/^cascaded/i){
return new Lingua::Align::LinkSearch::Cascaded(%attr);
}
if ($type=~/^viterbi/i){
return new Lingua::Align::LinkSearch::Viterbi(%attr);
}
Lingua-EN-Ngram
view release on metacpan or search on metacpan
etc/rivers.txt view on Meta::CPAN
the salt billows of the ocean on Plum Island beach. At first it
comes on murmuring to itself by the base of stately and retired
mountains, through moist primitive woods whose juices it
receives, where the bear still drinks it, and the cabins of
settlers are far between, and there are few to cross its stream;
enjoying in solitude its cascades still unknown to fame; by long
ranges of mountains of Sandwich and of Squam, slumbering like
tumuli of Titans, with the peaks of Moosehillock, the Haystack,
and Kearsarge reflected in its waters; where the maple and the
raspberry, those lovers of the hills, flourish amid temperate
dews;--flowing long and full of meaning, but untranslatable as
etc/rivers.txt view on Meta::CPAN
inexhaustible ledges of granite, with Squam, and Winnipiseogee,
and Newfound, and Massabesic Lakes for its mill-ponds, it falls
over a succession of natural dams, where it has been offering its
_privileges_ in vain for ages, until at last the Yankee race came
to _improve_ them. Standing at its mouth, look up its sparkling
stream to its source,--a silver cascade which falls all the way
from the White Mountains to the sea,--and behold a city on each
successive plateau, a busy colony of human beaver around every
fall. Not to mention Newburyport and Haverhill, see Lawrence,
and Lowell, and Nashua, and Manchester, and Concord, gleaming one
above the other. When at length it has escaped from under the
etc/rivers.txt view on Meta::CPAN
the same channel, but a new water every instant.
"Virtues as rivers pass,
But still remains that virtuous man there was."
Most men have no inclination, no rapids, no cascades, but
marshes, and alligators, and miasma instead. We read that when
in the expedition of Alexander, Onesicritus was sent forward to
meet certain of the Indian sect of Gymnosophists, and he had told
them of those new philosophers of the West, Pythagoras, Socrates,
and Diogenes, and their doctrines, one of them named Dandamis
Lingua-EN-Opinion
view release on metacpan or search on metacpan
lib/Lingua/EN/Opinion/Emotion.pm view on Meta::CPAN
cartouche => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
cartridge => { anger => 0, anticipation => 0, disgust => 0, fear => 1, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
carve => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
carver => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
carving => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
cascade => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 1, sadness => 0, surprise => 0, trust => 0 },
case => { anger => 0, anticipation => 0, disgust => 0, fear => 1, joy => 0, negative => 1, positive => 0, sadness => 1, surprise => 0, trust => 0 },
casein => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
cash => { anger => 1, anticipation => 1, disgust => 0, fear => 1, joy => 1, negative => 0, positive => 1, sadness => 0, surprise => 0, trust => 1 },
cashier => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 1 },
cashmere => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
Lingua-EN-SENNA
view release on metacpan or search on metacpan
lib/Lingua/EN/SENNA/third-party/senna/hash/ner.loc.lst view on Meta::CPAN
casa grande
casablanca
casablance
casanova
casar
cascade
cascade locks
cascadia
cascais
cascavel
cascilla
casco
Lingua-EN-Segment
view release on metacpan or search on metacpan
share/count_1w.txt view on Meta::CPAN
cruiser 3735652
hendrix 3734885
cumberland 3734672
gifted 3733747
esteem 3733585
cascade 3732995
endorse 3732894
strokes 3732810
shelby 3732559
hen 3732543
homeowner 3732354
share/count_1w.txt view on Meta::CPAN
rewriting 1160587
bahama 1160583
unrest 1160513
idl 1160460
loretta 1160225
cascades 1160207
druid 1160196
dunbar 1160179
outsider 1160162
lingvosoft 1160159
dax 1160128
share/count_1w.txt view on Meta::CPAN
iwon 183906
patchogue 183905
digestibility 183900
archaea 183898
enquired 183895
cascaded 183890
aphorisms 183889
sharkoon 183884
cmj 183869
spyderco 183865
compleat 183864
Lingua-EN-Tagger
view release on metacpan or search on metacpan
Tagger/words.yml view on Meta::CPAN
Carver: { nnp: 3 }
carves: { vbz: 1 }
carving: { vbg: 1 }
Caryl: { nnp: 1 }
Casablanca: { nnp: 4 }
cascade: { nn: 2 }
Cascade: { nnp: 5 }
cascading: { jj: 1, vbg: 1 }
case-by-case: { jj: 5 }
CASE: { nn: 1 }
case: { nn: 384 }
( run in 2.495 seconds using v1.01-cache-2.11-cpan-e7c6538aa59 )