view release on metacpan or search on metacpan
Shell/Menu.pm view on Meta::CPAN
-variable => \$self->options->{display_format},
-value => $_,
);
}
$menus_ref->cascade( -label => qq{Display format...});
$menus_ref->entryconfigure(
qq{Display format...}, -menu => $opt_disp,
-state => q{normal});
# Create the entries for rows returned.
Shell/Menu.pm view on Meta::CPAN
$opt_row->radiobutton( -label => $_, -variable => \$self->options->{rows},
-value => $_ );
}
$menus_ref->cascade( -label => qq{Rows return...} );
$menus_ref->entryconfigure( qq{Rows return...},
-menu => $opt_row,
-state => q{disabled});
}
view release on metacpan or search on metacpan
orac_Shell.pm view on Meta::CPAN
-variable => \$opt_dis_grid,
-value => $_,
);
}
$menus[2]->cascade( -label => "Display format...");
$menus[2]->entryconfigure( "Display format...", -menu => $opt_disp);
$opt_dis_grid = 'neat';
# Create the entries for rows returned.
my $opt_row = $menus[2]->menu->Menu;
foreach (qw/1 10 25 50 100 all/) {
$opt_row->radiobutton( -label => $_, -variable => \$opt_row_dis_c,
-value => $_ );
}
$menus[2]->cascade( -label => "Rows return..." );
$menus[2]->entryconfigure( "Rows return...", -menu => $opt_row);
$opt_row_dis_c = 'all';
# Create a button bar.
$dbistatus = "Creating menu button bar";
view release on metacpan or search on metacpan
lib/Orochi.pm view on Meta::CPAN
=head2 bind_value($path) or bind_value(\@paths)
Creates a BindValue injection, which is a lazy evaluation based on a
Orochi key.
If given a list, will cascade through the given paths until one returns a
defined value
=head2 inject_constructor($path => %injection_args)
Injects an object constructor. Setter injection also uses this
view release on metacpan or search on metacpan
lib/Oryx.pm view on Meta::CPAN
my $parent_section_instance = $paragraph->PARENT('CMS::Section');
and then use this instance normally.
Updates and deletes cascade up the inheritance chain, as you'd expect.
=head1 ABSTRACT CLASSES
Abstract classes to Oryx are simply classes which do not define any
attributes, but may have associations. The effect is automatic.
view release on metacpan or search on metacpan
lib/Otogiri/Plugin/DeleteCascade.pm view on Meta::CPAN
use Otogiri;
use Otogiri::Plugin;
use DBIx::Inspector;
our @EXPORT = qw(delete_cascade);
sub delete_cascade {
my ($self, $table_name, $cond_href) = @_;
my @parent_rows = $self->select($table_name, $cond_href);
my $inspector = DBIx::Inspector->new(dbh => $self->dbh);
my $iter = $inspector->table($table_name)->pk_foreign_keys();
lib/Otogiri/Plugin/DeleteCascade.pm view on Meta::CPAN
my $child_column_name = $child_table_fk_info->fkcolumn_name;
my $child_delete_condition = {
$child_column_name => $parent_row->{$parent_column_name},
};
$affected_rows += $db->delete_cascade($child_table_name, $child_delete_condition);
}
return $affected_rows;
}
lib/Otogiri/Plugin/DeleteCascade.pm view on Meta::CPAN
my $db = Otogiri->new( connect_info => $connect_info );
$db->insert('parent_table', { id => 123, value => 'aaa' });
$db->insert('child_table', { parent_id => 123, value => 'bbb'}); # child.parent_id referes parent_table.id(FK)
$db->delete_cascade('parent_table', { id => 123 }); # both parent_table and child_table are deleted.
=head1 DESCRIPTION
Otogiri::Plugin::DeleteCascade is plugin for L<Otogiri> which provides cascading delete feature.
loading this plugin, C<delete_cascade> method is exported. C<delete_cascade> follows Foreign Keys(FK) and
delete data referred in these key.
=head1 NOTICE
Please DO NOT USE this module in production code and data. This module is intended to be used for data maintenance
lib/Otogiri/Plugin/DeleteCascade.pm view on Meta::CPAN
This module uses L<DBIx::Inspector> to access metadata(foreign keys). In some environment, database administrator
does not allow to access these metadata, In this case this module can't be used.
=head1 METHOD
=head2 $self->delete_cascade($table_name, $cond_href);
Delete rows that matched to $cond_href and child table rows that can be followed by Foreign Keys.
=head1 LICENSE
view release on metacpan or search on metacpan
script/tkpp view on Meta::CPAN
#=======
my $bar_menu = $main->Menu( -type => 'menubar', );
$main->configure( -menu => $bar_menu, );
# File Menu
my $file_menu = $bar_menu->cascade( -label => 'File', -tearoff => 0, );
$file_menu->command(
-label => '~Load configuration',
-command => [ \&load_pp_configuration, $main, $opt, $ref_options_pp ],
);
$file_menu->command(
script/tkpp view on Meta::CPAN
);
$file_menu->separator;
$file_menu->command( -label => '~Exit', -command => \&close_application, );
# Help Menu
my $help_menu = $bar_menu->cascade( -label => 'Help', -tearoff => 0, );
my $tkpp_pod_menu = $help_menu->command(
-label => '~Tkpp documentation',
-command => [ \&open_pod_documentation, $main, 'tkpp' ],
);
my $pp_pod_menu = $help_menu->command(
view release on metacpan or search on metacpan
Storable/Storable.xs view on Meta::CPAN
* We have a small run-time penalty here because we chose to factorise
* all tieds objects into the same routine, and not have a store_tied_hash,
* a store_tied_array, etc...
*
* Don't use a switch() statement, as most compilers don't optimize that
* well for 2/3 values. An if() else if() cascade is just fine. We put
* tied hashes first, as they are the most likely beasts.
*/
if (svt == SVt_PVHV) {
TRACEME(("tied hash"));
view release on metacpan or search on metacpan
lib/PDF/Builder/Docs.pm view on Meta::CPAN
=item _marker-*
I<extensions>: these are CSS property overides to the appearance of list item markers (the formatted counter or bullet in front of the item). These may be applied to an entire list by placing them in CSS <styleE<gt> or a style= attribute within <olE<...
The corresponding CSS attributes (color, font-family, font-style, font-size, font-weight) are cascaded as usual, and the _marker-* attributes are cascaded as usual. When outputting a list's marker, if the final C<_marker-*> property is not empty ('')...
If you are I<nesting> lists, C<_marker-*> properties will be inherited, as is the usual practice. If you want a nested list to use standard properties, you will need to cancel the current state of inherited C<_marker-*> propertie(s) by setting it/the...
=over
view release on metacpan or search on metacpan
GENERATED/PDL/OpenCV/Objdetect.pm view on Meta::CPAN
=over
=item filename
Name of the file from which the classifier is loaded. The file may contain an old
HAAR classifier trained by the haartraining application or a new cascade classifier trained by the
traincascade application.
=back
=cut
GENERATED/PDL/OpenCV/Objdetect.pm view on Meta::CPAN
=for example
$res = $obj->read($node);
@note The file may contain a new cascade classifier (trained traincascade application) only.
=cut
#line 250 "Objdetect.pm"
GENERATED/PDL/OpenCV/Objdetect.pm view on Meta::CPAN
$objects = $obj->detectMultiScale($image); # with defaults
$objects = $obj->detectMultiScale($image,$scaleFactor,$minNeighbors,$flags,$minSize,$maxSize);
The function is parallelized with the TBB library.
@note
- (Python) A face detection example using cascade classifiers can be found at
opencv_source_code/samples/python/facedetect.py
Parameters:
=over
GENERATED/PDL/OpenCV/Objdetect.pm view on Meta::CPAN
Parameter specifying how many neighbors each candidate rectangle should have
to retain it.
=item flags
Parameter with the same meaning for an old cascade as in the function
cvHaarDetectObjects. It is not used for a new cascade.
=item minSize
Minimum possible object size. Objects smaller than that are ignored.
GENERATED/PDL/OpenCV/Objdetect.pm view on Meta::CPAN
Parameter specifying how many neighbors each candidate rectangle should have
to retain it.
=item flags
Parameter with the same meaning for an old cascade as in the function
cvHaarDetectObjects. It is not used for a new cascade.
=item minSize
Minimum possible object size. Objects smaller than that are ignored.
GENERATED/PDL/OpenCV/Objdetect.pm view on Meta::CPAN
=for ref
=for example
$res = PDL::OpenCV::CascadeClassifier::convert($oldcascade,$newcascade);
=cut
#line 617 "Objdetect.pm"
view release on metacpan or search on metacpan
nls/nls.sql view on Meta::CPAN
unique(msgid, context),
unique(msgid_plural, context)
);
create table nls_message (
id_nls_msgid integer not null references nls_msgid(id_nls_msgid) on delete cascade,
short char(2) not null references nls_lang(short) on delete cascade,
message_json text not null,
unique (id_nls_msgid, short)
);
create index i_nls_message_short_id_nls_msgid on nls_message (short,id_nls_msgid);
view release on metacpan or search on metacpan
lib/PINE64/MAX7219.pm view on Meta::CPAN
#output displayed on rising edge of LOAD
#NOTES:
#This version supports cascading several 7219's. I have
#noticed that even with programs that assume only one
#7219, that if there is another cascaded, the exact same
#output is mirrored on subsequent displays.
#I assume that turn_on, set_intenisty, set_scanlimit, etc
#all get shifted into the next chip anyway, however,
#these subroutines take the number of cascaded 7219s as
#an argument and shift in and latch the necessary
#controls to use the display.
#global vars for gpio init function
lib/PINE64/MAX7219.pm view on Meta::CPAN
#array ref seg data
my $leds = $_[0];
#array ref seg addr
my $addr = $_[1];
#number cascaded 7219s
my $ncas = $_[2];
#delay in milliseconds
my $delay = $_[3];
#latch flag
my $lf = $_[4];
lib/PINE64/MAX7219.pm view on Meta::CPAN
$ln++;
}#end for
}#end print_interleaved
sub turn_on{
#ncas is number of cascaded MAX7219 displays
my $ncas = $_[1];
if(defined($ncas)){
#print "tu ncas defined\n";
for(my $ni=0;$ni<$ncas;$ni++){
shift_in(\@turn_on, \@sdreg, $ncas, 250, 0);
lib/PINE64/MAX7219.pm view on Meta::CPAN
shift_in(\@turn_on, \@sdreg, 1, 250, 1);
}#end else
}#end turn_on
sub turn_off{
#ncas is number of cascaded MAX7219 displays
my $ncas = $_[1];
if(defined($ncas)){
for(my $ni=0;$ni<$ncas;$ni++){
shift_in(\@turn_off, \@sdreg, $ncas, 250, 0);
if($ni ==($ncas-1)){
lib/PINE64/MAX7219.pm view on Meta::CPAN
shift_in(\@turn_off, \@sdreg, 1, 250, 1);
}#end else
}#end turn_off
sub set_scanlimit{
#ncas is number of cascaded MAX7219 displays
my $ncas = $_[1];
if(defined($ncas)){
#print "sl ncas defined\n";
for(my $ni=0;$ni<$ncas;$ni++){
shift_in(\@slregall, \@slimreg, $ncas, 250, 0);
lib/PINE64/MAX7219.pm view on Meta::CPAN
=head1 DESCRIPTION
This module is a driver for 8-digit seven-segment MAX7219 displays. It
is implemented as bit-banged SPI. Using the object's methods, you can
set the intensity of the display, print words, and cascade multiple
displays. It also comes with several built-in effects.
Only three GPIO pins are required: SPI clk, SPI data, and SPI chip
select. This modules uses the PINE64::GPIO numbering scheme.
lib/PINE64/MAX7219.pm view on Meta::CPAN
Takes the GPIO pin numbers that will be used to inplement the bit-bang
SPI interface to the MAX7219 as arguments. Returns an object to
control an 8-digit display.
=head2 shift_in($leds, $digit, $n_cascaded, $delay, $latch_flag)
This method is only used internally. It takes an array of a single
seven-segment's LEDs, the digit position, the number of cascaded
MAX7219 displays, a delay in usec (between SPI clock pulses), and a
latch flag. Each individual letter of a word is shifted in one at
a time. Once all the letters are shifted in, the latch_flag is set
high, and displays the word.
lib/PINE64/MAX7219.pm view on Meta::CPAN
displays each word for $delay micro seconds. $sentence could be the
text of an entire book. $clear_flag is not required.
=head2 print_interleaved($string1, $string2)
This method is for use with two 8-digit displays cascaded. $string1
will be displayed in the first display, $string2 in the cascaded
display.
=head2 turn_on($num_cascaded)
Turns on the MAX7219 chip by writing to the turn on register. Takes
the number of cascaded displays as an argument. Enter 1 if only
using one display.
=head2 set_scanlimit($num_cascaded)
Writes to the scan-limit register. Sets it up to use all 8-digits
of the display. Takes number of cascaded displays an arg.
=head2 set_intensity($intensity);
Adjusts the brightness of the display. Takes a string as an arg.
Valid vlaues are: min, dim, mid, bright, max.
=head2 all_off($num_cascaded)
Turns off all digits. Takes number of cascaded displays as an arg.
=head2 disp_teston()
Turns on all segments on all digits.
view release on metacpan or search on metacpan
htdocs/examples/dojo/dojo/dojo.js.uncompressed.js view on Meta::CPAN
// NOTE: this has been tested with larger and smaller user-set text
// sizes and works fine
ns.zoom = "1";
// node.style.zoom = "normal";
}
// don't set the width to auto if it didn't already cascade that way.
// We don't want to f anyones designs
if(!ns.width.length && d.style(node, "width") == "auto"){
ns.width = "auto";
}
} : function(){};
view release on metacpan or search on metacpan
lib/POE/Request.pm view on Meta::CPAN
A canceled request cannot generate a response. If you are tempted to
precede cancel() with emit(), then use return() instead. The return()
method is essentially an emit() followed by a cancel().
As mentioned earlier, canceling a request frees up the data associated
with that request. Cancellation and destruction cascade through the
data associated with a request and any sub-stages and sub-requests.
This efficiently and automatically releases all resources associated
with the entire request tree rooted with the canceled request.
For example:
lib/POE/Request.pm view on Meta::CPAN
HTTP client creates a request for a socket.
Socket factory creates a request for a DNS resolver.
At any point in the hierarchy, a cancellation clears its context and
cancels the lower-level requests. For example, if the App cancels the
HTTP request, the cancelation cascades to the socket factory, and then
to the DNS resolver.
This happens because of one recursive rule: When a request is
canceled, the data members on both sides of the transaction are
destroyed. This only works when stages consistently store subrequests
view release on metacpan or search on metacpan
lib/POE/Kernel.pm view on Meta::CPAN
$kr_active_session->_register_state($event, $state_code, $state_alias);
return 0;
}
# TODO A terminal signal (such as UIDESTROY) kills a session. The
# Kernel deallocates the session, which cascades destruction to its
# HEAP. That triggers a Wheel's destruction, which calls
# $kernel->state() to remove a state from the session. The session,
# though, is already gone. If TRACE_RETVALS and/or ASSERT_RETVALS
# is set, this causes a warning or fatal error.
view release on metacpan or search on metacpan
lib/PPI/Tokenizer.pm view on Meta::CPAN
delete $self->{line_length};
return 0;
}
# In the scan version, just set the cursor to the end
# of the line, and the rest should just cascade out.
$self->{line_cursor} = $self->{line_length};
return 0;
}
# Populate the appropriate variables
view release on metacpan or search on metacpan
PPresenter/Viewport/BackgroundMenu.pm view on Meta::CPAN
( -label => 'Start callbacks'
, -variable=> \$show->{-enableCallbacks}
);
$menu->add
( 'cascade'
, -label => 'phases'
, -menu => $phases
);
$screen->bind("<Key-space>", sub {$show->addPhase(1);} );
PPresenter/Viewport/BackgroundMenu.pm view on Meta::CPAN
$screen->bind("<Key-h>", sub {$show->setRunning(0);} );
$screen->bind("<Key-n>", sub {$show->showSlide('NEXT_SELECTED');} );
$screen->bind("<Key-N>", sub {$show->showSlide('NEXT');} );
$screen->bind("<Key-p>", sub {$show->showSlide('PREVIOUS');} );
$menu->add('cascade'
, -label => 'steps'
, -menu => $steps
);
if($has_popup)
PPresenter/Viewport/BackgroundMenu.pm view on Meta::CPAN
, -label => "$_"
, -command => [sub {$_[0]->popup($show, $viewport->{-display})},$_ ]
);
}
$menu->add('cascade'
, -label => 'export'
, -menu => $export
);
}
view release on metacpan or search on metacpan
share/doc/wxwidgets.pod view on Meta::CPAN
=head2 Wx::MDIParentFrame::Cascade
void Cascade()
Arranges the MDI child windows in a cascade.
See also
wxMDIParentFrame::Tile, wxMDIParentFrame::ArrangeIcons
view release on metacpan or search on metacpan
lib/Padre/Wx/Role/View.pm view on Meta::CPAN
=head2 view_label
The method returns the string that the notebook label should be filled
with. This should be internationalised properly. This method is called
once when the object is constructed, and again if the user triggers a
C<relocale> cascade to change their interface language.
=head2 view_close
This method is called on the object by the event handler for the "X"
control on the notebook label, if it has one.
view release on metacpan or search on metacpan
lib/LWP/Parallel.pm view on Meta::CPAN
# let's see what we got back (see also callback function!!)
foreach (keys %$entries) {
$res = $entries->{$_}->response;
# examine response to find cascaded requests (redirects, etc) and
# set current response to point to the very first response of this
# sequence. (not very exciting if you set '$pua->redirect(0)')
my $r = $res; my @redirects;
while ($r) {
$res = $r;
view release on metacpan or search on metacpan
root/static/yui/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>
*
view release on metacpan or search on metacpan
t/10_basic.t view on Meta::CPAN
},
);
test_service(
service_name => 'upupup',
desc => 'cascade envdir',
new_argv => {
base_dir => $BASE_DIR,
},
status_argv => {
env_dir => [
view release on metacpan or search on metacpan
lib/Parse/Dia/SQL.pm view on Meta::CPAN
$assocName, ## From table
$leftFKName, ## name of foreign key constraint
$leftFKCols, ## foreign key column in assoc tbl
$leftClassLookup->{name}, ## Table referenced
$leftEndCols, ## Column in table referenced
'on delete cascade' ## Trash when no longer referenced
);
# generate the constraint code:
# referenced attribute <- foreign key
$self->{log}->debug("Call save_foreign_key (right to left)");
$self->save_foreign_key($assocName, $rightFKName, $rightFKCols,
$rightClassLookup->{name},
$rightEndCols, 'on delete cascade');
return 1;
}
# Create datastructure that represents given Table or View SQL and
lib/Parse/Dia/SQL.pm view on Meta::CPAN
elsif ( $aggregation == 1 ) { # Aggregation
$constraintAction = 'on delete set NULL';
$defFKnull = 'null';
}
elsif ( $aggregation == 2 ) { # Composition
$constraintAction = 'on delete cascade';
}
}
else {
# ERD interpretation
lib/Parse/Dia/SQL.pm view on Meta::CPAN
if ( $constraintAction =~ /on\s+delete\s+set\s+null/i ) {
$defFKnull = 'null';
}
# tedia2sql v1.2.9b usage of 'on delete clause'
# The 'on cascade delete' clauses were on opposite ends of
# the association for one-to-many and one-to-one for ERD mode!
# if ($arity eq 'zmany' && $fkMult eq 'undef') {
# $constraintAction = $fkEnd->{'multiplicity'};
# $fkMult = 'none';
# } elsif ($arity eq 'zone' && $pkMult eq 'undef') {
view release on metacpan or search on metacpan
lib/Parse/Eyapp.pod view on Meta::CPAN
one that is acceptable. In the example
all the tokens until finding a C<'\n'> will be skipped.
If no special error productions have been specified,
the processing will halt.
In order to prevent a cascade of error messages, the parser, after
detecting an error, remains in error state until three tokens have been
successfully read and shifted. If an error is detected when the parser
is already in error state, no message is given, and the input token is
quietly deleted. The method C<YYErrok> used in the example
communicates to the parser
view release on metacpan or search on metacpan
examples/8.1/asup01.txt view on Meta::CPAN
vol.move.cutover.disk.busy.limit 100
vol.snaprestore.nondisruptive off
vsm.smtape.concurrent.cascade.support off
wafl.cpdump.level 1
wafl.cpdump.threshold 60
view release on metacpan or search on metacpan
lib/Parse/Vipar/Shell.pm view on Meta::CPAN
$modifier = 'Control';
} elsif ($^O eq 'MacOS') { # one of these days
$modifier = 'Command';
}
my $m_file = $menubar->cascade(-label => '~File', -tearoff => 0);
$m_file->command(-label => 'Load ~Parser...',
-command => sub {
$self->fileDialog("load parser %s",
["YACC files", '*.y'])
});
view release on metacpan or search on metacpan
share/utils/cpanm 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.
share/utils/cpanm 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
view release on metacpan or search on metacpan
lib/Perl/Metrics/File.pm view on Meta::CPAN
'path', # Absolute local filesystem path - '/foo/bar/baz.pm'
'checked', # UNIX epoch time last checked - '1128495103'
'hex_id', # Document MD5 Identifier - 'abcdef1234567890'
);
# Add custom deletion cascade
Perl::Metrics::File->add_trigger(
before_delete => sub { $_[0]->before_delete },
);
sub before_delete {
my $self = shift;
view release on metacpan or search on metacpan
bin/perltidy view on Meta::CPAN
cbo=1 If the first of a pair of blocks is broken in the input
file, then break the second [DEFAULT].
cbo=2 Break open all blocks for maximal cuddled formatting.
The default and recommended value is B<cbo=1>. With this value, if the starting
block of a chain spans multiple lines, then a cascade of breaks will occur for
remaining blocks causing the entire chain to be cuddled.
The option B<cbo=0> can produce erratic cuddling if there are numerous one-line
blocks.
bin/perltidy view on Meta::CPAN
C<elsif>, and C<else> blocks, we could use
C<perltidy -bli -bbvt=1 -bbvtl='if elsif else'>.
There is no vertical tightness control for closing block braces; with
one exception they will be placed on separate lines.
The exception is that a cascade of closing block braces may
be stacked on a single line. See B<--stack-closing-block-brace>.
=item B<-sot>, B<--stack-opening-tokens> and related flags
The B<-sot> flag tells perltidy to "stack" opening tokens
bin/perltidy view on Meta::CPAN
-sobb or --stack-opening-block-brace
The flag B<-sot> is an abbreviation for B<-sop -sohb -sosb>.
The flag B<-sobb> is an abbreviation for B<-bbvt=2 -bbvtl='*'>. This
will case a cascade of opening block braces to appear on a single line,
although this an uncommon occurrence except in test scripts.
=item B<-sct>, B<--stack-closing-tokens> and related flags
The B<-sct> flag tells perltidy to "stack" closing tokens
bin/perltidy view on Meta::CPAN
-scbb or --stack-closing-block-brace
The flag B<-sct> is an abbreviation for stacking the non-block closing
tokens, B<-scp -schb -scsb>.
Stacking of closing block braces, B<-scbb>, causes a cascade of isolated
closing block braces to be combined into a single line as in the following
example:
# -scbb:
for $w1 (@w1) {
view release on metacpan or search on metacpan
lib/Perl5/CoreSmokeDB/Schema/Result/Config.pm view on Meta::CPAN
__PACKAGE__->has_many(
"results",
"Perl5::CoreSmokeDB::Schema::Result::Result",
{ "foreign.config_id" => "self.id" },
{ cascade_copy => 0, cascade_delete => 0 },
);
# Created by DBIx::Class::Schema::Loader v0.07049 @ 2022-09-06 09:15:22
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:l/lxpTgyv35unrcVapM8JQ
view release on metacpan or search on metacpan
share/Apocalypse/A03.pod view on Meta::CPAN
and:
$file.is_readable
Similar to the cascaded filetest ops in the previous section, one
approach might be that the boolean methods return the object in
question for success so that method calls could be stacked without
repeating the object:
if ($file.is_dir
share/Apocalypse/A03.pod view on Meta::CPAN
some object containing the stat buffer (represented in Perl 5 by the
C<_> character). If we did that, we wouldn't have to play C<$file is
true> games, because a valid stat buffer object would (presumably)
always be true (at least until it's false).
The same argument would apply to cascaded filetest operators we talked
about earlier. An autoloaded C<-drwx> handler would presumably be smart
enough to do a single stat. But we'd likely lose the speed gain by
invoking the autoload mechanism. So cascaded operators (either C<-X>
style or C<.is_XXX> style) are the way to go. They just return objects
that know how to be either boolean or stat buffer objects in context.
This implies you could even say
$statbuf = -f $file or die "Not a regular file: $file";