view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/RoutesAuthDBI/Schema.pm view on Meta::CPAN
status int not null, --- http
elapsed numeric not null ---seconds from mojo.timer
);
@@ drop
--drop table "{%= $schema %}"."{%= $tables->{refs} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{logins} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{profiles} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{roles} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{routes} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{controllers} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{actions} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{namespaces} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{oauth_sites} %}" cascade;
--drop table "{%= $schema %}"."{%= $tables->{oauth_users} %}" cascade;
drop schema "{%= $schema %}" cascade;
drop sequence {%= $sequence %};
@@ flush
delete from "{%= $schema %}"."{%= $tables->{refs} %}";
delete from "{%= $schema %}"."{%= $tables->{logins} %}";
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/SQLiteViewerLite/public/js/jquery-1.9.1.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
view release on metacpan or search on metacpan
lib/MongoDBx/Class/Document.pm view on Meta::CPAN
=head2 remove()
Both methods are equivalent. They are shortcut methods for invoking the
collection's C<remove()> method on this document only. So, umm, they remove
the document. But note that this operation does not cascade, so documents
which are considered dependant on this document (such as those that reference
it with C<belongs_to>) will not be removed too.
=cut
view release on metacpan or search on metacpan
lib/Mongoose/Engine.pm view on Meta::CPAN
}
return undef;
}
#sub delete_cascade {
# my ($self, $args )=@_;
# #TODO delete related collections
#}
sub db {
view release on metacpan or search on metacpan
lib/Monitoring/GLPlugin/SNMP/MibsAndOids/EMDMIB.pm view on Meta::CPAN
deviceInetIPAddress => '1.3.6.1.4.1.13742.8.1.1.1.10',
deviceInetNetmask => '1.3.6.1.4.1.13742.8.1.1.1.11',
deviceInetGateway => '1.3.6.1.4.1.13742.8.1.1.1.12',
serverCount => '1.3.6.1.4.1.13742.8.1.1.1.13',
model => '1.3.6.1.4.1.13742.8.1.1.1.14',
cascadedDeviceConnected => '1.3.6.1.4.1.13742.8.1.1.1.15',
logConfiguration => '1.3.6.1.4.1.13742.8.1.1.2',
dataLogging => '1.3.6.1.4.1.13742.8.1.1.2.1',
measurementPeriod => '1.3.6.1.4.1.13742.8.1.1.2.2',
measurementsPerLogEntry => '1.3.6.1.4.1.13742.8.1.1.2.3',
logSize => '1.3.6.1.4.1.13742.8.1.1.2.4',
view release on metacpan or search on metacpan
t/20-complex_filter.t view on Meta::CPAN
"Filter: state = 1",
"Or: 2",
"Filter: group >= linux",
],
# cascaded query
[
-and => [
-or => [
state => { '=' => 0 },
state => { '=' => 1 },
view release on metacpan or search on metacpan
t/20-complex_filter.t view on Meta::CPAN
"Filter: state = 1",
"Or: 2",
"Filter: group >= linux",
],
# cascaded query
[
-and => [
-or => [
state => { '=' => 0 },
state => { '=' => 1 },
view release on metacpan or search on metacpan
lib/MooX/PluginKit/Consumer.pm view on Meta::CPAN
has_pluggable_object foo_bar => (
class => 'Foo::Bar',
);
This function acts like L<Moo/has> but adds a bunch of functionality,
making it easy to cascade the creation of objects which automatically
have applicable plugins applied to them, at run-time.
In the above C<foo_bar> example, the user of your class can then specify
the C<foo_bar> argument as a hashref. This hashref will be used to
create an object of the C<Foo::Bar> class, but not until after any
view release on metacpan or search on metacpan
lib/MooseX/CascadeClearing.pm view on Meta::CPAN
}
=head1 DESCRIPTION
MooseX::CascadeClearing does the necessary metaclass fiddling to allow an
clearing one attribute to be cascaded through to other attributes as well,
calling their clear accessors.
The intended purpose of this is to assist in situations where the value of one
attribute is derived from the value of another attribute -- say a situation
where the secondary value is expensive to derive and is thus lazily built. A
lib/MooseX/CascadeClearing.pm view on Meta::CPAN
=for Pod::Coverage init_meta
=head1 CAVEAT
We don't yet trigger a cascade clear on a master attribute's value being set
through a setter/accessor accessor. This will likely be available as an
option in the not-too-distant-future.
=head1 ATTRIBUTE OPTIONS
lib/MooseX/CascadeClearing.pm view on Meta::CPAN
=back
=head1 SOURCE
The development version is on github at L<http://github.com/RsrchBoy/moosex-cascadeclearing>
and may be cloned from L<git://github.com/RsrchBoy/moosex-cascadeclearing.git>
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website
https://github.com/RsrchBoy/moosex-cascadeclearing/issues
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
view release on metacpan or search on metacpan
lib/MooseX/ConfigCascade.pm view on Meta::CPAN
our $VERSION = '0.02';
use Moose::Role;
use MooseX::ConfigCascade::Util;
has cascade_util => (is => 'ro', lazy => 1, isa => 'MooseX::ConfigCascade::Util', default => sub{
MooseX::ConfigCascade::Util->new(
_to_set => $_[0],
_role_name => __PACKAGE__
);
});
sub BUILD{}
after BUILD => sub{
my ($self,$args) = @_;
my $util = $self->cascade_util;
foreach my $k (keys %$args){ $util->_args->{$k} = 1 }
$util->_parse_atts;
};
lib/MooseX/ConfigCascade.pm view on Meta::CPAN
with 'MooseX::ConfigCascade';
When you do this, a single new attribute is added to your class:
=head2 cascade_util
This is a L<MooseX::ConfigCascade::Util> object, which has 3 utility methods. So once you added the L<MooseX::ConfigCascade> role to your package, you can do:
my $object = My::Package->new;
$object->cascade_util->conf; # access the config hash directly
$object->cascade_util->path; # the path to the config file (if any)
$object->cascade_util->parser; # the code ref to the subroutine which parses your config file
Note C<conf>, C<path> and C<parser> are all B<class attributes> of L<MooseX::ConfigCascade::Util>. That means it is intended that you generally set them by calling the class directly:
MooseX::ConfigCascade::Util->path( '/path/to/config.yaml' );
# etc ...
so you may not ever need to use C<cascade_util> at all. However, you may find it useful that you can access the full config from anywhere in your project:
$whatever_object->cascade_util->conf;
See the documentation for L<MooseX::ConfigCascade::Util> for information about these methods.
=head1 SEE ALSO
view release on metacpan or search on metacpan
lib/Multi/Dispatch.pm view on Meta::CPAN
}
This code uses a single multisub with a signature, to ensure that it receives
the correct kind of argument. But then it unpacks the contents of that argument
"manually", and determines what action to take by explicitly deciphering the
structure of the argument in a cascaded S<C<if>-C<elsif>> sequence...all in that
single variant.
Avoiding that kind of all-in-one hand-coded infrastructure is the entire
reason for having multiple dispatch, so it won't come as much of a surprise
that Multi::Dispatch offers a much cleaner way of achieving the same goal:
lib/Multi/Dispatch.pm view on Meta::CPAN
}
While this is a arguably little cleaner than the array-based version,
and certainly a lot safer I<(are you B<sure> all the array indexes
were correct in the array-based version???)>, it still suffers from
the "all-in-one-cascade" problem.
Fortunately, Multi::Dispatch can also destructure hashref parameters,
allowing them to be specified as destructuring anonymous hashes:
multi handle( { cmd=>'delete', ID=>$ID } ) {...}
view release on metacpan or search on metacpan
lib/MyCPAN/Indexer/Interface/Tk.pm view on Meta::CPAN
{
my $menubar = shift;
my $title = shift;
my $items = shift;
my $menu = $menubar->cascade(
-label => $title,
-menuitems => $items,
-tearoff => 0,
);
view release on metacpan or search on metacpan
htdocs/src-min/mode-mysql.js view on Meta::CPAN
define("ace/mode/doc_comment_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("./text_highlight_rules").TextHighlightRules,s=function(){this.$rules={s...
view release on metacpan or search on metacpan
lib/MySQL/Workbench/Parser/MySQLParser.pm view on Meta::CPAN
|
/on update/i reference_option
{ $item[2] }
reference_option: /restrict/i |
/cascade/i |
/set null/i |
/no action/i |
/set default/i
{ $item[1] }
view release on metacpan or search on metacpan
0.003 Wed Aug 23 14:31:56 EST 2006
. fix bug in handling US style dates (Don Collins)
. allow use 'Mar 20006' (to select an arbitrary month) in constructor
. add some tests of the named Month facility (t/st_et.t)
. refactor the __DEFAULT__ handler of the %stime_etime despatch table to use
ternary (what C calls 'conditional') statements instead of cascaded if-then-else
. allow time selectors to have an optional argument of a datetime. This allows
tests to be pre-genned with known dates rather than having to dynamically cope with
whatever time the test is called at (see gen_tests, which generates t/st_et_2.t).
. modify examples/host_down_report to accept named Months as time option.
view release on metacpan or search on metacpan
Roadmap.org view on Meta::CPAN
* rename ?
- 'cascade copy' was probably a bad idea
- GRID-Copy ?
- google finds 21,200 for "grid copy"
view release on metacpan or search on metacpan
lib/Net/IMP/Cascade.pm view on Meta::CPAN
$new_parts[$i] = $np; # got new factory for part
}
return $factory if ! @new_parts; # interface supported by original factory
# some parts changed, create new factory for this cascade
for(my $i=0;$i<@$parts;$i++) {
$new_parts[$i] ||= $parts->[$i]; # copy parts which did not change
}
return ref($factory)->new_factory( parts => \@new_parts );
lib/Net/IMP/Cascade.pm view on Meta::CPAN
end => 0, # end of buf relativ to part
data => '', # data or undef for replace_later
dtype => 0, # data type
rtype => IMP_PASS, # IMP_PASS < IMP_PREPASS < IMP_REPLACE
gap => 0, # size of gap before buf?
gstart => 0, # start of buf relativ to cascade
gend => 0, # end of buf relativ to cascade
eof => 0 # flag if last buf in this direction
});
%$buf = ( %$buf, @_ ) if @_;
return $buf;
};
lib/Net/IMP/Cascade.pm view on Meta::CPAN
$buf->{end} = $buf->{start} + length($buf->{data});
$DEBUG && debug(
"fwd_next[$dir][$pi>$npi] ".$dump_bufs->([$buf]));
$part_in->($npi,$dir,$buf);
} else {
# output from cascade
my $cb = $fwd_up->($dir,$buf) or next;
$DEBUG && debug(
"fwd_up[$dir][$pi>>] ".$dump_bufs->([$buf]));
$wself->run_callback($cb);
}
lib/Net/IMP/Cascade.pm view on Meta::CPAN
__END__
=head1 NAME
Net::IMP::Cascade - manages cascade of IMP filters
=head1 SYNOPSIS
use Net::IMP::Cascade;
use Net::IMP::Pattern;
lib/Net/IMP/Cascade.pm view on Meta::CPAN
Net::IMP::SessionLog->new_factory..,
]);
=head1 DESCRIPTION
C<Net::IMP::Cascade> puts multiple IMP analyzers into a cascade.
Data get analyzed starting with part#0, then part#1... etc for direction 0
(client to server), while for direction 1 (server to client) the data get
analyzed the opposite way, ending in part#0.
The only argument special to C<new_factory> is C<parts>, which is an array
view release on metacpan or search on metacpan
lib/Net/LCDproc/Screen.pm view on Meta::CPAN
$widget->screen($self);
push @{$self->widgets}, $widget;
return 1;
}
# removes screen from N::L, deletes from server, then cascades and kills its widgets (optionally not)
sub remove {
my ($self, $keep_widgets) = @_;
if (!defined $keep_widgets) {
foreach my $widget (@{$self->widgets}) {
view release on metacpan or search on metacpan
extras/oui-20151113.txt view on Meta::CPAN
0CD996 (base 16) Cisco Systems, Inc
80 West Tasman Drive
San Jose CA 94568
US
D8-2D-E1 (hex) Tricascade Inc.
D82DE1 (base 16) Tricascade Inc.
5020 Campus Drv.
Newport Beach CA 92660
US
C4-38-D3 (hex) TAGATEC CO.,LTD
view release on metacpan or search on metacpan
lib/Net/OAuth2/Scheme.pm view on Meta::CPAN
$factory_class = $Factory_Class;
}
eval "require $factory_class" or die $@;
my $factory = $factory_class->new(@_);
# start the cascade of methods being implemented
$factory->uses('root');
# build the object, make sure the method definitions are there
my $tag =
pop @{$free_tags{$class} ||= []}
view release on metacpan or search on metacpan
lib/Net/OnlineCode/Bones.pm view on Meta::CPAN
When matched, the propagation rule solves one extra node somewhere to
the left of the starting node. In the algebraic interpretation, I
talked about substituting a newly-solved variable into all other
equations where the variable appeared. There is an analogous procedure
in the graph-based implementation, which is implemenented in the
cascade() routine.
For the sake of discussion, let's assume that the message block M was
solved by the propagation rule and that it had the solution:
M <- A xor C
lib/Net/OnlineCode/Bones.pm view on Meta::CPAN
one rightward edge in the graph from that node for each equation the
left node appears in, this effectively reaches all equations that
could could become solvable.
In the case where the left node which has become solved is an
auxiliary block, the cascade() routine also queues up the auxiliary
node itself for checking the propagation rule.
=head2 Special handling for auxiliary nodes
Although in theory the propagation rule could be applied to unsolved
lib/Net/OnlineCode/Bones.pm view on Meta::CPAN
x i j
When the last unsolved message block on the right becomes solved then
this equation has no more unknowns apart from the aux block
itself. Therefore, it can be marked as solved (with the above
solution) and we can cascade up from that aux block to see if it
solves any more equations.
=head2 Optimising by tracking counts of unsolved left nodes
When aux or check nodes are created, the number of unknown/unsolved
view release on metacpan or search on metacpan
lib/Net/SSLeay.pod view on Meta::CPAN
=item msg 123: 1 - error:140770F8:SSL routines:SSL23_GET_SERVER_HELLO:unknown proto
SSLeay error string. The first number (123) is the PID, the second number
(1) indicates the position of the error message in SSLeay error stack.
You often see a pile of these messages as errors cascade.
=item msg 123: 1 - error:02001002::lib(2) :func(1) :reason(2)
The same as above, but you didn't call load_error_strings() so SSLeay
couldn't verbosely explain the error. You can still find out what it
view release on metacpan or search on metacpan
t/fam/sprites/accept.png
t/fam/sprites/add.png
t/fam/sprites/anchor.png
t/fam/sprites/application.png
t/fam/sprites/application_add.png
t/fam/sprites/application_cascade.png
t/fam/sprites/application_delete.png
t/fam/sprites/application_double.png
t/fam/sprites/application_edit.png
t/fam/sprites/application_error.png
t/fam/sprites/application_form.png
view release on metacpan or search on metacpan
t/data/out_I_A_thaliana.obo view on Meta::CPAN
relationship: part_of APO:P0000104 ! meiosis I
[Term]
id: APO:P0000055
name: DNA damage response, signal transduction by p53 class mediator resulting in cell cycle arrest
def: "A cascade of processes induced by the cell cycle regulator phosphoprotein p53, or an equivalent protein, in response to the detection of DNA damage and resulting in the stopping or reduction in rate of the cell cycle." [GOC:go_curators]
xref: GO:0006977
is_a: APO:P0000158 ! G1 DNA damage checkpoint
[Term]
id: APO:P0000056
view release on metacpan or search on metacpan
lib/OOP/Perlish/Class.pm view on Meta::CPAN
sub ____inherit_accessors(@)
{
my ($self) = @_;
### Protect overloaded accessors by identifying those in our top-level namespace
### This cascaded up through the inheritance tree
my %top_accessors = ();
if( scalar( keys %{ $self->____OOP_PERLISH_CLASS_ACCESSORS() } ) ) {
# XXX: Hash slice assignment
@top_accessors{ keys %{ $self->____OOP_PERLISH_CLASS_ACCESSORS() } } =
( (1) x ( ( scalar keys %{ $self->____OOP_PERLISH_CLASS_ACCESSORS() } ) ) );
lib/OOP/Perlish/Class.pm view on Meta::CPAN
while( my ( $name, $field ) = each %{ $self->____OOP_PERLISH_CLASS_ACCESSORS() } ) {
$required_fields{$name} = $name if( $field->required() );
}
# FIXME: Does not cascade beyond @ISA, should traverse inheritance tree and ensure that all required fields are
# provided for any hiararchy. ... does cascade via new, but only to ancesters who conform with us. unsure how to fix
#for my $parent_class ( @{ $self->{____CLASS_ISA} } ) {
for my $parent_class ( $self->_all_isa() ) {
if( bless( {}, $parent_class )->can('____OOP_PERLISH_CLASS_REQUIRED_FIELDS') ) {
@required_fields{ @{ $parent_class->____OOP_PERLISH_CLASS_REQUIRED_FIELDS() } } =
@{ $parent_class->____OOP_PERLISH_CLASS_REQUIRED_FIELDS() };
lib/OOP/Perlish/Class.pm view on Meta::CPAN
my %opts =
map { ( $_ => $self->{____oop_perlish_class_opts}->{$_} ) }
grep { !exists( $required_fields_lut{$_} ) } keys %{ $self->{____oop_perlish_class_opts} };
# prepopulate accessors so that calls that cascade will have values assigned
# Set everything by accessor that we ->can()
while( my ( $method, $value ) = each %opts ) {
$self->$method($value) if( $self->can($method) );
}
$self->____validate_defaults();
# reset all accessors for actually set values, re-running cascades where applicable...
# there must be a better way, but this works
while( my ( $method, $value ) = each %opts ) {
$self->$method($value) if( $self->can($method) );
}
return;
view release on metacpan or search on metacpan
- Allow ->load calls for multiple-columns primary keys
- All connections now explicitly RaiseError => 1 for correctness
- All connections now explicitly PrintError => 0 to avoid spewing
stuff to STDOUT/STDERR unexpectedly in embedded scenarios.
- Remove most explicit error handling and allow the native DBI
errors to cascade upwards instead.
1.29_01 2009-09-28
- Adding first experimental implementation of ->load
1.28 2009-09-25
view release on metacpan or search on metacpan
ObjectivePerl.pm view on Meta::CPAN
invoke those methods using obj-c style messages. However,
there are often times when you need to call older perl code that
does not list its arguments in its signature, or perhaps you wish
to invoke a method across the PerlObjCBridge in OSX. To do
this transparently, the ObjectivePerl runtime uses a method lookup
cascade that works as follows:
1. It tries to find the correctly-defined method
for the invocation using ObjectivePerl syntax
2. (NEW in 0.03 for CamelBones Compatibility)
It tries to find a method whose name corresponds
view release on metacpan or search on metacpan
xs/SceneNode.xs view on Meta::CPAN
SceneNode *
SceneNode::getParentSceneNode()
void
SceneNode::setVisible(bool enabled, bool cascade=true)
void
SceneNode::flipVisibility(bool cascade=true)
void
SceneNode::setDebugDisplayEnabled(bool enabled, bool cascade=true)
## static void queueNeedUpdate (Node *n)
## static void processQueuedUpdates (void)
view release on metacpan or search on metacpan
lib/OpenGL/Sandbox/VertexArray.pm view on Meta::CPAN
=head2 bind
$vertex_array->bind($program, $buffer);
Make the configuration of this vertex array active for drawing. This might cause a cascade of
effects, like binding buffers, loading buffers, binding the vertex array object, looking up
program attributes, and enabling and configuring the attributes. Steps which don't need
repeated won't be.
If C<$program> is not given, the current one will be used for any attribute-index lookups.
view release on metacpan or search on metacpan
OpenIndex.pm view on Meta::CPAN
$new{options_del} = ($parent->{options_del} | $current->{options_del}) ;
$new{options} = $parent->{options} & ~NO_OPTIONS;
} else { # not all incremental, so no inheritance
$new{options} = $current->{options};
}
# Collect cascaded options
$new{options} |= $new{options_add};
$new{options} &= ~ $new{options_del};
}
$new{userdir} = $current->{userdir} || $parent->{userdir};
$new{usersite} = $current->{usersite} || $parent->{usersite};