Result:
found more than 741 distributions - search limited to the first 2001 files matching your query
( run in 2.308 )
Catmandu-PICA
view release on metacpan or search on metacpan
t/files/picaxml.xml view on Meta::CPAN
</datafield>
<datafield tag="016H">
<subfield code="0">Elektronische Ressource</subfield>
</datafield>
<datafield tag="020F">
<subfield code="a">The agricultural world has changed significantly during the last years. The excessive use of heavy machinery, waste disposal, the use of agrochemicals and new soil cultivation means led to severe problems, which agricultural en...
</datafield>
<datafield tag="021A">
<subfield code="a">Soil Engineering. (Soil Biology, Vol 20)</subfield>
</datafield>
<datafield tag="028A">
Catmandu-PNX
view release on metacpan or search on metacpan
<subject>laboratoriumaantekeningen</subject>
<subject>onderscheidingen</subject>
<subject>memorabilia</subject>
<subject>tekeningen</subject>
<subject>foto's</subject>
<subject>fragmenten (kunst)</subject>
<subject>publicaties</subject>
<subject>manuscripten</subject>
<subject>drukproeven (gedrukt materiaal)</subject>
<subject>correspondence</subject>
<subject>lecture notes</subject>
<subject>laboratoriumaantekeningen</subject>
<subject>onderscheidingen</subject>
<subject>memorabilia</subject>
<subject>tekeningen</subject>
<subject>foto's</subject>
<subject>fragmenten (kunst)</subject>
<subject>publicaties</subject>
<subject>manuscripten</subject>
<subject>drukproeven (gedrukt materiaal)</subject>
<subject>correspondence</subject>
<subject>lecture notes</subject>
<topic>laboratoriumaantekeningen</topic>
<topic>onderscheidingen</topic>
<topic>memorabilia</topic>
<topic>tekeningen</topic>
<topic>foto's</topic>
<topic>fragmenten (kunst)</topic>
<topic>publicaties</topic>
<topic>manuscripten</topic>
<topic>drukproeven (gedrukt materiaal)</topic>
<topic>correspondence</topic>
<topic>lecture notes</topic>
Catmandu-RDF
view release on metacpan or search on metacpan
lib/Catmandu/Fix/rdf_ldf_statements.pm view on Meta::CPAN
with 'Catmandu::Fix::SimpleGetValue';
sub _build_client {
my ($self) = @_;
my $url = $self->url // 'http://data.linkeddatafragments.org/viaf';
RDF::LDF->new(url => $url);
}
sub emit_value {
my ($self,$var,$fixer) = @_;
lib/Catmandu/Fix/rdf_ldf_statements.pm view on Meta::CPAN
=head1 SYNOPSIS
# Replace a name with an array of matching VIAF records
# name: "\"Einstein, Albert, 1879-1955\""
rdf_ldf_statements(name,url:"http://data.linkedatafragments.org/viaf",predicate:"http://schema.org/alternateName")
# name:
# - http://viaf.org/viaf/75121530
=head1 DESCRIPTION
This L<Catmandu::Fix> can be used to find at a Linked Data Fragments endpoint
all subject URIs for which the object has a specific value found at a path. E.g.
rdf_ldf_statements(name,url:"http://data.linkedatafragments.org/viaf")
means, search at the endpoint http://data.linkedatafragments.org/viaf all the
subjects for which the object is the value found in 'name', and replace the name value
with all the found subjects.
=head1 ARGUMENTS
Catmandu-SRU
view release on metacpan or search on metacpan
t/files/marcxml.xml view on Meta::CPAN
<subfield code="b">Amsterdam : Elsevier,</subfield>
<subfield code="c">2005</subfield>
</datafield>
<datafield tag="520" ind1="3" ind2=" ">
<subfield code="a">This book is dedicated to the multiple aspects, that is, biological, physical and computational of DNA and RNA molecules. These molecules, central to vital processes, have been experimentally studied by molecular biologists for...
</datafield>
<datafield tag="852" ind1=" " ind2=" ">
<subfield code="a">ULB</subfield>
Catmandu-XSD
view release on metacpan or search on metacpan
lib/Catmandu/XSD.pm view on Meta::CPAN
# Hello, I'm <name>John</name> how can I <bold>help</bold> you?
#
# => { name => 'John' , bold => 'help' }
catmandu XSD --root ... --schema mixed.xsd --mixed STRUCTURAL < data.xml
# The mixed elements will be a plain XML fragment string
#
# Hello, I'm <name>John</name> how can I <bold>help</bold> you?
#
# => $r = 'Hello, I'm <name>John</name> how can I <bold>help</bold> you?'
catmandu XSD --root ... --schema mixed.xsd --mixed XML_STRING < data.xml
Cavil-Matcher
view release on metacpan or search on metacpan
docs/Architecture.md view on Meta::CPAN
concepts, not functions or line numbers.
## Why this exists
Cavil reviews the licensing of software by scanning source code for the text of known licenses. The scanning
is done by matching every file against a large, ever-growing collection of *patterns* - normalized fragments
of license text. The previous engine did this well and fast, and this one keeps its core idea unchanged. What
it changes is everything around that core, because the old design had three operational problems that grow
worse over time:
- **Every change rebuilt the world.** Adding or editing a single pattern threw away the entire compiled
collection, and the next scan had to recompile all of it from scratch. Patterns are added every day, so
this cost was paid constantly.
- **Every worker kept its own copy.** Cavil scans in parallel with many worker processes, and each one loaded
its own full copy of the compiled patterns into private memory. The more patterns, the more this multiplied.
- **The on-disk form was fragile.** The compiled file had no header, version, or checksum; it was trusted
blindly. A format change or a truncated file could be silently misread.
The goal of this engine is to fix those three things - cheap incremental updates, one shared copy per machine,
and a safe, versioned on-disk format - while keeping matching itself bit-for-bit identical, so switching to it
requires no re-processing of existing data.
docs/Architecture.md view on Meta::CPAN
## Fingerprinting for snippet provenance
The pattern engine answers "which known licenses does this file contain". A closely related question is
"which known open source code does this snippet resemble", used by a service where someone submits a
fragment (for example AI-generated code) and asks how much of it already exists in the open source Cavil
has seen. This distribution provides the *primitives* for that question. The searchable index that turns
fingerprints back into packages and paths lives in the consuming application - Cavil keeps it in Postgres -
not here.
Two calls make up the surface. `content_hash` returns the 128-bit hash of a file's raw bytes as 32 hex
docs/Architecture.md view on Meta::CPAN
- **The database remains the source of truth** for patterns. The compiled segments are a derived cache that
can always be rebuilt from it.
- **The prefix tree remains the authoritative matcher.** Similarity scoring and closest-match are useful for
suggestions, never for the authoritative yes/no of whether a license is present.
- **The tokenizer and the hashing are frozen** and produce exactly the same numbers as before. Because the
stored checksums of patterns and text fragments depend on those numbers, keeping them identical means the
new engine can replace the old one without recomputing or migrating any stored data.
## Scaling characteristics and limits
The two costs that grew worst in the old design are gone: a change no longer recompiles the whole collection,
CfgTie
view release on metacpan or search on metacpan
docs/CSS.tex view on Meta::CPAN
@chapter Adding your own style sheet
The various modules provide methods for generating HTML fragments, something
@file{sys.cgi} (@pxref{sys.cgi}) uses as an example. The HTML is done in a
style-sheet friendly way.
Cascading Style Sheets (CSS) are easy enough that we recommend looking at the
existing style sheet (@file{cgi/CfgTie.css}) and skim the spec
docs/CSS.tex view on Meta::CPAN
CfgTie uses the @samp{cfgval} class to indicate values for various settings,
and @samp{cfgattr} to indicate the variable names that are being set.
@heading Nesting in style sheets
The following CSS fragment means that paragraphs nested inside TDs of class
@samp{cfgattr} will have black text and yellow backgrounds.
@example
TD.cfgattr P @{ color: black; background: yellow; @}
@end example
Chandra
view release on metacpan or search on metacpan
/*
* Chandra.xs - Root XS file
*
* Thin wrapper: includes shared header (which provides all static
* C functions when WEBVIEW_IMPLEMENTATION is defined), then pulls
* in per-module XS fragments via INCLUDE:.
*/
#define WEBVIEW_IMPLEMENTATION
#define CHANDRA_XS_IMPLEMENTATION
#define CHANDRA_WINDOW_IMPLEMENTATION
Changes
view release on metacpan or search on metacpan
lib/Changes/Version.pm view on Meta::CPAN
my $self = shift( @_ );
$self->{alpha} = undef;
# Used for other version types
$self->{beta} = undef;
$self->{compat} = 0;
# What version fragment to increase/decrease by default, such as when we do operations like $v++ or $v--
$self->{default_frag} = 'minor';
$self->{extra} = [];
$self->{major} = undef;
$self->{minor} = undef;
$self->{original} = undef;
$self->{padded} = 1;
lib/Changes/Version.pm view on Meta::CPAN
$self->{qv} = 0;
# Release candidate used by non-perl open source softwares
$self->{rc} = undef;
$self->{target} = 'perl';
$self->{type} = undef;
my $keys = [qw( alpha beta compat default_frag extra major minor original patch qv rc target type _version )];
my $vstr;
# Changes::Version->new( 'v0.1.2_3' ); or
# Changes::Version->new( 'v0.1.2_3', alpha => 4 ); or
# Changes::Version->new( 'v0.1.2_3', { alpha => 4 } ); or
# Changes::Version->new( major => 0, minor => 1, patch => 2, alpha => 3, qv => 1 ); or
lib/Changes/Version.pm view on Meta::CPAN
sub dec_minor { return( shift->_inc_dec( 'dec' => 'minor', @_ ) ); }
sub dec_patch { return( shift->_inc_dec( 'dec' => 'patch', @_ ) ); }
sub default_frag { return( shift->_set_get_scalar_as_object( 'default_frag', @_ ) ); }
sub extra { return( shift->_set_get_array_as_object( 'extra', @_ ) ); }
sub format
{
lib/Changes/Version.pm view on Meta::CPAN
if( $] >= 5.008_001 && ref( \$str ) eq 'VSTRING' )
{
my $def = { original => $str };
$def->{type} = 'dotted';
$def->{qv} = 1;
my @frags = map{ ord( $_ ) } split( //, $str );
@$def{qw( major minor patch )} = splice( @frags, 0, 3 );
$def->{extra} = \@frags;
$def->{pattern} = '%R%d';
my $new = $self->new( %$def );
$new->{_version} = version->parse( $str );
return( $new );
}
lib/Changes/Version.pm view on Meta::CPAN
{
if( defined( $re2->{minor_patch} ) )
{
# delete( $def->{alpha} );
$def->{major} = $re2->{major};
my @frags = split( /\./, $re2->{minor_patch} );
shift( @frags );
$def->{minor} = shift( @frags );
$def->{patch} = shift( @frags );
$def->{extra} = \@frags;
}
}
}
}
else
lib/Changes/Version.pm view on Meta::CPAN
# Same as %M%P%E -> 5.3.4.5.6.7.8
push( @$fmt, '%d' );
push( @$fmt, '%a' ) if( defined( $def->{alpha} ) && length( $def->{alpha} ) );
if( defined( $re->{minor_patch} ) )
{
my @frags = split( /\./, $re->{minor_patch} );
# throw away the empty data because of the leading dot
shift( @frags );
$def->{minor} = shift( @frags );
$def->{patch} = shift( @frags );
$def->{extra} = \@frags;
}
}
$def->{pattern} = join( '', @$fmt );
}
elsif( $def->{type} eq 'decimal' )
lib/Changes/Version.pm view on Meta::CPAN
# {
# if( defined( $re2->{minor_patch} ) )
# {
# # delete( $def->{alpha} );
# $def->{major} = $re2->{major};
# my @frags = split( /\./, $re2->{minor_patch} );
# shift( @frags );
# $def->{minor} = shift( @frags );
# $def->{patch} = shift( @frags );
# $def->{extra} = \@frags;
# }
# }
# }
# }
}
lib/Changes/Version.pm view on Meta::CPAN
}
sub _bubble
{
my $self = shift( @_ );
my $frag = shift( @_ );
my $val = shift( @_ );
# We die, because this is an internal method and those cases should not happen unless this were a design bug
if( !defined( $frag ) || !length( $frag ) )
{
die( "No fragment was provided to cascade" );
}
elsif( $frag !~ /^(major|minor|patch|alpha|\d+)$/ )
{
die( "Unsupported version fragment '$frag'. Only use 'major', 'minor', 'patch' or 'alpha' or a number starting from 1 (1 = major, 2 = minor, etc)." );
}
# Not for us. We bubble only when a value is negative resulting from a cascading decrease
# e.g. 3.12.-1 -> 3.11.0, or 3.0.-1 -> 2.9.0, or 2.-1 -> 1.0
elsif( $val >= 0 )
{
return;
}
my $type = $self->type;
my $extra = $self->extra;
my $frag_is_int = ( $frag =~ /^\d+$/ ? 1 : 0 );
my $frag2num =
{
major => 1,
minor => 2,
patch => 3,
};
my $num2frag =
{
1 => 'major',
2 => 'minor',
3 => 'patch',
};
if( $frag eq 'alpha' )
{
$self->alpha( undef );
return;
}
die( "Fragment provided '$frag' cannot be 0." ) if( $frag_is_int && $frag == 0 );
my $level = $frag_is_int ? $frag : $frag2num->{ $frag };
# Should not be happening
if( $type eq 'decimal' && $level > 2 )
{
$self->patch( undef );
lib/Changes/Version.pm view on Meta::CPAN
my $new_val = 0;
unless( $i == 1 )
{
my $up_val;
my $j = $i - 1;
if( exists( $num2frag->{ $j } ) )
{
my $coderef = $self->can( $num2frag->{ $j } ) ||
die( "Cannot find reference for method ", $num2frag->{ $j } );
$up_val = $coderef->( $self );
}
else
{
$up_val = $extra->[ $j - 4 ];
lib/Changes/Version.pm view on Meta::CPAN
# Set value for next iteration
$val = ( $up_val // 0 ) - 1;
$new_val = ( $up_val > 0 ) ? 9 : 0;
}
if( exists( $num2frag->{ $i } ) )
{
# my $coderef = $self->can( $num2frag->{ $i } ) ||
# die( "Cannot find reference for method ", $num2frag->{ $i } );
# $coderef->( $self, 0 );
$self->{ $num2frag->{ $i } } = $new_val;
}
else
{
$extra->[ $i - 4 ] = $new_val;
}
}
else
{
if( exists( $num2frag->{ $i } ) )
{
# my $coderef = $self->can( $num2frag->{ $i } ) ||
# die( "Cannot find reference for method ", $num2frag->{ $i } );
# $coderef->( $self, 0 );
$self->{ $num2frag->{ $i } } = $val;
}
else
{
$extra->[ $i - 4 ] = $val;
}
lib/Changes/Version.pm view on Meta::CPAN
}
sub _cascade
{
my $self = shift( @_ );
my $frag = shift( @_ );
# We die, because this is an internal method and those cases should not happen unless this were a design bug
if( !defined( $frag ) || !length( $frag ) )
{
die( "No fragment was provided to cascade" );
}
elsif( $frag !~ /^(major|minor|patch|alpha|\d+)$/ )
{
die( "Unsupported version fragment '$frag'. Only use 'major', 'minor', 'patch' or 'alpha' or a number starting from 1 (1 = major, 2 = minor, etc)." );
}
my $type = $self->type;
my $extra = $self->extra;
my $frag_is_int = ( $frag =~ /^\d+$/ ? 1 : 0 );
if( $frag eq 'major' || ( $frag_is_int && $frag == 1 ) )
{
$self->alpha( undef );
$self->patch(0);
# $self->patch( $type eq 'decimal' ? undef : 0 );
$self->minor(0);
}
elsif( $frag eq 'minor' || ( $frag_is_int && $frag == 2 ) )
{
$self->alpha( undef );
$self->patch(0);
# $self->patch( $type eq 'decimal' ? undef : 0 );
}
elsif( $frag eq 'patch' || ( $frag_is_int && $frag == 3 ) )
{
$self->alpha( undef );
}
elsif( $frag eq 'alpha' )
{
# Nothing to do
}
elsif( $type eq 'dotted' && $frag_is_int )
{
my $offset = ( $frag - 4 );
my $len = $extra->length;
# Before the fragment offset, we set the value to 0 if it is undefined or empty, and
# after the fragment offset everything else is reset to 0
for( my $i = 0; $i < ( $offset < $len ? $len : $offset ); $i++ )
{
if( (
$i < $offset &&
( !defined( $extra->[$i] ) || !length( $extra->[$i] ) )
lib/Changes/Version.pm view on Meta::CPAN
sub _compute
{
my $self = shift( @_ );
my $opts = pop( @_ );
my( $other, $swap, $nomethod, $bitwise ) = @_;
my $frag = $self->default_frag // 'minor';
$frag = 'minor' if( $frag !~ /^(major|minor|patch|alpha|\d+)$/ );
if( !defined( $opts ) ||
ref( $opts ) ne 'HASH' ||
!exists( $opts->{op} ) ||
!defined( $opts->{op} ) ||
!length( $opts->{op} ) )
lib/Changes/Version.pm view on Meta::CPAN
die( "No argument 'op' provided" );
}
my $op = $opts->{op};
my $clone = $self->clone;
my $extra = $self->extra;
my $frag_is_int = ( $frag =~ /^\d+$/ ? 1 : 0 );
my $map =
{
1 => 'major',
2 => 'minor',
3 => 'patch',
};
my $coderef;
if( ( $frag_is_int && exists( $map->{ $frag } ) ) || !$frag_is_int )
{
$coderef = $self->can( $map->{ $frag } // $frag ) ||
die( "Cannot find code reference for method ", ( $frag_is_int ? $map->{ $frag } : $frag ) );
}
my $val = defined( $coderef ) ? $coderef->( $self ) : $extra->[ $frag - 4 ];
my $err;
if( !defined( $val ) )
{
$val = $self->new_number(0);
}
lib/Changes/Version.pm view on Meta::CPAN
$new_val = int( $rv );
}
if( $new_val < 0 )
{
$new->_bubble( $frag, $new_val );
}
else
{
if( defined( $coderef ) )
{
$coderef->( $new, $new_val );
}
else
{
$extra->[( $frag - 4 )] = $new_val;
}
$new->_cascade( $frag );
}
$new->reset(1);
return( $new );
}
}
lib/Changes/Version.pm view on Meta::CPAN
sub _inc_dec
{
my $self = shift( @_ );
my $op = shift( @_ ) || return( $self->error( "No op was provided." ) );
return( $self->error( "Op can only be 'inc' or 'dec'" ) ) if( $op !~ /^(inc|dec)$/ );
my $frag = shift( @_ );
my $unit = shift( @_ );
if( !defined( $frag ) || !length( "$frag" ) )
{
return( $self->error( "No version fragment was specified to ", ( $op eq 'inc' ? 'increase' : 'decrease' ), " the version number." ) );
}
elsif( $frag !~ /^(major|minor|patch|alpha|\d+)$/ )
{
return( $self->error( "Unsupported version fragment '$frag' to ", ( $op eq 'inc' ? 'increase' : 'decrease' ), ". Only use 'major', 'minor', 'patch' or 'alpha' or a number starting from 1 (1 = major, 2 = minor, etc)." ) );
}
if( defined( $unit ) && $unit !~ /^\d+$/ )
{
return( $self->error( "Unit to ", ( $op eq 'inc' ? 'increase' : 'decrease' ), " fragment $frag value must be an integer." ) );
}
my $extra = $self->extra;
my $frag_is_int = ( $frag =~ /^\d+$/ ? 1 : 0 );
my $map =
{
1 => 'major',
2 => 'minor',
3 => 'patch',
};
my $coderef;
if( ( $frag_is_int && exists( $map->{ $frag } ) ) || !$frag_is_int )
{
$coderef = $self->can( $map->{ $frag } // $frag ) ||
die( "Cannot find code reference for method ", ( $frag_is_int ? $map->{ $frag } : $frag ) );
}
my $n = defined( $coderef ) ? $coderef->( $self ) : $extra->[ $frag - 4 ];
# The offset specified is out of bound
if( $frag_is_int && ( $frag - 4 ) > $extra->size )
{
$n = (
$op eq 'inc'
? ( defined( $unit ) ? $unit : 1 )
: 0
lib/Changes/Version.pm view on Meta::CPAN
{
$coderef->( $self, $n );
}
else
{
$extra->[( $frag - 4 )] = $n;
}
$self->_cascade( $frag );
$self->reset(1);
return( $self );
}
sub _noop
lib/Changes/Version.pm view on Meta::CPAN
$comp->push( $self->extra->list );
}
for( qw( patch minor major ) )
{
next if( !length( $def->{ $_ } ) && !$ok );
# We stop skipping version fragments as soon as one is defined
$ok++;
$comp->unshift( $def->{ $_ } );
}
my $v = ( $self->qv ? 'v' : '' ) . $comp->map(sub{ 0 + $_ })->join( '.' )->scalar;
$v .= '_' . $def->{alpha} if( defined( $def->{alpha} ) && length( $def->{alpha} ) );
lib/Changes/Version.pm view on Meta::CPAN
$v->type( 'dotted' );
$v++;
# Updating 'minor'
say "$v"; # v1.3.0
$v += 2;
$v->default_frag( 'major' );
$v++;
say "$v"; # v2.0.0
$v->inc_patch;
say $v->is_alpha; # false
say $v->numify; # returns new Changes::Version object
lib/Changes/Version.pm view on Meta::CPAN
=over 4
=item * C<alpha>
Specifies the alpha fragment integer of the version. See L</alpha> for more information.
my $v = Changes::Version->new(
major => 1,
minor => 2,
patch => 3,
lib/Changes/Version.pm view on Meta::CPAN
$v->alpha(7);
say "$v"; # v1.2.3_7
=item * C<beta>
Specifies the beta fragment integer of the version. See L</beta> for more information.
Currently unused and reserved for future release.
=item * C<compat>
Boolean. When enabled, this will ensure the version formatting is strictly compliant with the L<version> module. Default to false.
=item * C<default_frag>
Specifies the fragment name or integer value used by overloaded operations.
my $v = Changes::Version->new( 'v1.2.3_4' );
my $default = $v->default_frag; # By default 'minor'
$v->default_frag( 'major' );
$v++; # Version is now v2.2.3_4
=item * C<extra>
Specifies the array reference of version fragments beyond C<patch>
my $v = Changes::Version->new(
major => 1,
minor => 2,
patch => 3,
lib/Changes/Version.pm view on Meta::CPAN
say "$v"; # v1.2.3.4.5.6.7_12
my $a = $v->extra; # contains 4, 5, 6, 7
=item * C<major>
Specifies the C<major> fragment of the version string.
my $v = Changes::Version->new(
major => 1,
minor => 2,
patch => 3,
lib/Changes/Version.pm view on Meta::CPAN
$v->major(3);
say "$v"; # v3.0.0
=item * C<minor>
Specifies the C<minor> fragment of the version string.
my $v = Changes::Version->new(
major => 1,
minor => 2,
patch => 3,
lib/Changes/Version.pm view on Meta::CPAN
$v->padded(0);
say "$v"; # 1.0203
=item * C<patch>
Specifies the C<patch> fragment of the version string.
my $v = Changes::Version->new(
major => 1,
minor => 2,
patch => 3,
lib/Changes/Version.pm view on Meta::CPAN
=head1 METHODS
=head2 alpha
Sets or gets the C<alpha> fragment integer of the version.
Setting this to C<undef> effectively removes it.
Returns a L<number object|Module::Generic::Number>
lib/Changes/Version.pm view on Meta::CPAN
# No change, using the cache
say "$v"; # v1.2.4
=head2 beta
The beta fragment integer of the version. This is currently unused and reserved for future release of this class.
=head2 compat
Boolean. When enabled, this will ensure the version formatting is strictly compliant with the L<version> module. Default to false.
=head2 dec
Provided with a version fragment, and an optiona integer, and this will decrease the version fragment value by as much. If no integer is provided, the default decrement is 1.
my $v = Changes::Version->new(
major => 1,
minor => 2,
patch => 3,
lib/Changes/Version.pm view on Meta::CPAN
say "$v"; # v1.2.3_3;
$v->dec( 'patch', 2 );
say "$v"; # v1.2.1
my $v = Changes::Version->new( 'v1.2.3.4.5.6.7_8' );
# Decrease the 5th fragment
$v->dec(5);
say "$v"; # v1.2.3.4.4.0.0
Any change to a fragment value will reset the lower fragment values to zero. Thus:
=over 4
=item * changing the C<major> value will reset C<minor> and C<patch> to 0 and C<alpha> to C<undef>
=item * changing the C<minor> value will reset C<patch> to 0 and C<alpha> to C<undef>
=item * changing the C<patch> value will reset C<alpha> to C<undef>
=item * changing the nth fragment value will reset all fragment value after that to 0
=back
If you pass a fragment that is an integer and it is outside the maximum number of fragments, it will automatically expand the number of version fragments and initialise the intermediary fragments to 0. A fragment as an integer starts at 1.
Using the example above:
$v->dec(10);
say "$v"; # v1.2.3.4.5.6.7.0.0.0
The 10th element is set to 0 because it does not exist, so it cannot be decreased.
=head2 dec_alpha
This is a shortcut for calling L</dec> on fragment C<alpha>
=head2 dec_beta
This is a shortcut for calling L</dec> on fragment C<beta>
=head2 dec_major
This is a shortcut for calling L</dec> on fragment C<major>
=head2 dec_minor
This is a shortcut for calling L</dec> on fragment C<minor>
=head2 dec_patch
This is a shortcut for calling L</dec> on fragment C<patch>
=head2 default_frag
my $v = Changes::Version->new( 'v1.2.3_4' );
my $default = $v->default_frag; # By default 'minor'
$v->default_frag( 'major' );
$v++; # Version is now v2.2.3_4
String. Sets or gets the name or the integer value for the version fragment. Supported value can be C<major>, C<minor>. C<patch>, C<alpha>, or an integer.
Returns a L<scalar object|Module::Generic::Scalar>
=head2 extra
Sets or gets an array reference of version fragments starting from C<1> for C<major>, C<2> for C<minor>, C<3> for C<patch>, etc. For example:
my $v = Changes::Version->new( 'v1.2.3.4.5.6.7_8' );
my $a = $v->extra; # contains 4, 5, 6, 7
Note that C<alpha> is not accessible via digits, but only using L</alpha>
lib/Changes/Version.pm view on Meta::CPAN
Same as L</dec>, but increasing instead of decreasing.
=head2 inc_alpha
This is a shortcut for calling L</inc> on fragment C<alpha>
=head2 inc_beta
This is a shortcut for calling L</inc> on fragment C<beta>
=head2 inc_major
This is a shortcut for calling L</inc> on fragment C<major>
=head2 inc_minor
This is a shortcut for calling L</inc> on fragment C<minor>
=head2 inc_patch
This is a shortcut for calling L</inc> on fragment C<patch>
=head2 is_alpha
Returns true if L</alpha> has a value set.
lib/Changes/Version.pm view on Meta::CPAN
Returns true if L</qv> is set to true, false otherwise.
=head2 major
Sets or gets the C<major> fragment of the version string.
my $v = Changes::Version->new( 'v1.2.3_4' );
my $major = $v->major; # 1
$v->major(3);
say "$v"; # v3.2.3_4
lib/Changes/Version.pm view on Meta::CPAN
Returns a L<number object|Module::Generic::Number>
=head2 minor
Sets or gets the C<minor> fragment of the version string.
my $v = Changes::Version->new( 'v1.2.3_4' );
my $minor = $v->minor; # 2
$v->minor(3);
say "$v"; # v1.3.3_4
lib/Changes/Version.pm view on Meta::CPAN
Returns a L<boolean object|Module::Generic::Boolean>
=head2 patch
Sets or gets the C<patch> fragment of the version string.
my $v = Changes::Version->new( 'v1.2.3_4' );
my $patch = $v->patch; # 3
$v->patch(5);
say "$v"; # v1.3.5_4
lib/Changes/Version.pm view on Meta::CPAN
=item * C<bool>
=item * C<+>, C<->, C<*>, C</>
When performing those operations, it will use the value of the fragment of the version set with L</default_frag>, which, by default, is C<minor>.
It returns a new L<Changes::Version> object reflecting the new version value. However, if the operation is swapped, with the version object on the right-hand side instead of the left-hand side, this will return a regular number.
my $vers = Changes::Version->new( 'v1.2.3_4' );
my $new_version_object = $vers + 2; # Now v1.4.3_4 (minor has been bumped up by 2)
$vers->default_frag( 'major' );
my $new_version_object = $vers + 2; # Now v3.2.3_4 (this time, 'major' was increased)
But, when swapped:
my $vers = Changes::Version->new( 'v1.2.3_4' );
my $n = 3 + $vers; # yields 5 (using the 'minor' fragment by default)
$vers->default_frag( 'major' );
my $n = 3 + $vers; # yields 4 (this time, using the 'major' fragment)
=item * C<+=>, C<-=>, C<*=>, C</=>
In this operations, it modifies the current object with the operand provided and returns the current object, instead of creating a new one.
my $vers = Changes::Version->new( 'v1.2.3_4' );
# By default, using the 'minor' fragment
$vers += 1; # version is now v2.2.3_4
$vers->default_frag( 'alpha' );
$vers /= 2; # version is now v1.2.3_2
=item * C<++>, C<-->
When using those operations, it updates the current object directly and returns it. For example:
my $vers = Changes::Version->new( 'v1.2.3_4' );
# By default, using the 'minor' fragment
$vers++; # version is now v1.3.3_4
=back
=head1 PATTERNS
lib/Changes/Version.pm view on Meta::CPAN
=item * C<%a>
my $v = Changes::Version->parse( "5.0.6_2" );
say $v->format( '%a' ); # 2
This will return the C<alpha> fragment value, if any.
If there is no C<alpha> fragment value, it returns an empty string.
=item * C<%D>
my $v = Changes::Version->parse( "5.0.6.1.2.3.4_2" );
say $v->format( '%D' ); # 0.6.1.2.3.4
my $v = Changes::Version->parse( "5.0.6" );
say $v->format( '%D' ); # 0.6
This will return the C<minor>, C<patch>, and any extra fragments.
This is designed for dotted-decimal types, and C<minor>, and C<patch> will always return a number, possibly C<0>
=item * C<%d>
lib/Changes/Version.pm view on Meta::CPAN
my $v = Changes::Version->parse( "5.2.6_3" );
say $v->format( '%M' ); # 2
This returns the C<minor> part of the version.
If there is no C<minor> fragment value, it returns an empty string.
=item * C<%m>
my $v = Changes::Version->parse( "5.2.6_3" );
say $v->format( '%m' ); # .2
lib/Changes/Version.pm view on Meta::CPAN
This is similar to C<%N>, but will prepend a dot if the value is not null.
=item * C<%P>
This returns the C<patch> fragment value of the version, if any.
If there is no C<patch> fragment value, it returns an empty string.
=item * C<%R>
This returns the C<major> fragment value of the version, if any.
If there is no C<major> fragment value, it returns an empty string.
=item * C<%U>
my $v = Changes::Version->parse( "5.2.6" ):
say $v->format( '%R.%U' ); # 5.002_006
say $v->format( '%U' ); # 002_006
This returns the C<minor> and C<patch> value of a dotted-decimal version as numified version using the underscore to separate the C<minor> and the C<patch> fragments.
=item * C<%u>
my $v = Changes::Version->parse( "5.2.6" ):
say $v->format( '%R%u' ); # 5.002_006
Chart-Plotly
view release on metacpan or search on metacpan
share/plotly.js/plotly.min.js view on Meta::CPAN
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
"use strict";var e=t("base64-js"),n=t("ieee754");r.Buffer=a,r.SlowBuffer=function(t){+t!=t&&(t=0);return a.alloc(+t)},r.INSPECT_MAX_BYTES=50;function i(t){if(t>2147483647)throw new RangeError('The value "'+t+'" is invalid for option "size"');var e=ne...
/*! Native Promise Only
v0.8.1 (c) Kyle Simpson
MIT License: http://getify.mit-license.org
*/
!function(t,r,n){r[t]=r[t]||n(),void 0!==e&&e.exports&&(e.exports=r[t])}("Promise",void 0!==t?t:this,(function(){"use strict";var t,e,n,i=Object.prototype.toString,a=void 0!==r?function(t){return r(t)}:setTimeout;try{Object.defineProperty({},"x",{}),...
share/plotly.js/plotly.min.js view on Meta::CPAN
/*
* @copyright 2016 Sean Connelly (@voidqk), http://syntheti.cc
* @license MIT
* @preserve Project Home: https://github.com/voidqk/polybooljs
*/
var n,i=t("./lib/build-log"),a=t("./lib/epsilon"),o=t("./lib/intersecter"),s=t("./lib/segment-chainer"),l=t("./lib/segment-selector"),c=t("./lib/geojson"),u=!1,f=a();function h(t,e,r){var i=n.segments(t),a=n.segments(e),o=r(n.combine(i,a));return n.p...
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
"use strict";var e=t("base64-js"),n=t("ieee754");r.Buffer=a,r.SlowBuffer=function(t){+t!=t&&(t=0);return a.alloc(+t)},r.INSPECT_MAX_BYTES=50;function i(t){if(t>2147483647)throw new RangeError('The value "'+t+'" is invalid for option "size"');var e=ne...
/*!
* Determine if an object is a Buffer
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
Chatbot-Eliza
view release on metacpan or search on metacpan
examples/deutsch.txt view on Meta::CPAN
reasmb: Stört es dich, (2) zu vergessen ?
reasmb: Könnte das eine geistige Sperre sein ?
reasmb: Bist du vergeßlich im allgemeinen ?
reasmb: Glaubst du, du unterdrückst (2) ?
decomp: * hast du * vergessen *
reasmb: Warum fragst du das ?
reasmb: Bist du sicher, daß du mir das gesagt hast ?
reasmb: Würde es dich stören, wenn ich (2) vergessen würde ?
reasmb: Warum soll ich mich jetzt an (2) erinnern ?
reasmb: goto was
reasmb: Sprich weiter über (2).
examples/deutsch.txt view on Meta::CPAN
reasmb: Willst du (2) können ?
reasmb: Vielleich willst du nicht (2).
reasmb: goto was
key: was 0
decomp: *
reasmb: Warum fragst du das ?
reasmb: Interessiert dich diese Frage ?
reasmb: Was willst du wirklich wissen ?
reasmb: Beschäftigen dich diese Fragen ?
reasmb: Welche Antwort würde dir am meisten gefallen ?
reasmb: Was denkst du ?
reasmb: Was noch kommt dir in die Gedanken, wenn du daran denkst ?
reasmb: Hast du solche Fragen schon früher gefragt ?
reasmb: Hast du schon jemanden anderen gefragt ?
key: wer 0
decomp: who *
reasmb: goto was
key: wann 0
decomp: when *
examples/deutsch.txt view on Meta::CPAN
reasmb: Wirklich, (2) ?
reasmb: Bestimmt nicht (2).
reasmb: Kannst du an jemanden besonderen denken ?
reasmb: Wer, zum Beispiel?
reasmb: Denkst du an eine ganz spezielle Person ?
reasmb: Wer, wenn ich fragen darf ?
reasmb: Vielleicht jemand spezielles ?
reasmb: Du denkst an eine bestimmte Person, nicht wahr ?
reasmb: Über wen sprichst du, deiner Meinung nach?
key: niemand 2
decomp: * niemand *
reasmb: Bist du sicher, daß niemand (2) ?
reasmb: Nein, bestimmt niemand (2) .
reasmb: Kannst du an irgendjemanden denken ?
reasmb: Denkst du an eine ganz spezielle Person ?
reasmb: Wer, wenn ich fragen darf ?
reasmb: Eigentlich denkst du an eine bestimmte Person, nicht wahr ?
reasmb: An wen denkst du wirklich ?
key: immer 1
decomp: *
reasmb: Kannst du ein Beispiel nennen ?
Cheater
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
? '{}'
: default_as_code($default);
my $code = $code{sub_start};
if ($args->{-init}) {
my $fragment = $args->{-weak} ? $code{weak_init} : $code{init};
$code .= sprintf $fragment, $field, $args->{-init}, ($field) x 4;
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
Chem-Structure-Parser
view release on metacpan or search on metacpan
lib/Chem/Structure/Parser.pm view on Meta::CPAN
}
if (my $e = $info->{entity_of_chain}{$cid}) {
$c->{mol_id} = $e->{mol_id};
$c->{molecule} = $e->{molecule} if defined $e->{molecule};
$c->{organism} = $e->{organism} if defined $e->{organism};
$c->{fragment} = $e->{fragment} if defined $e->{fragment};
$c->{ec} = $e->{ec} if defined $e->{ec};
}
$c->{dbref} = $info->{dbref}{$cid} if $info->{dbref}{$cid};
}
return $info;
lib/Chem/Structure/Parser.pm view on Meta::CPAN
my $s = $info->{source}{$id} || {};
for my $cid (@{ $c->{chain} || [] }) {
$by_chain{$cid} = {
mol_id => $id,
molecule => $c->{molecule},
fragment => $c->{fragment},
ec => $c->{ec_number} || $c->{ec},
organism => $s->{organism_scientific},
taxid => $s->{organism_taxid},
expressed_in => $s->{expression_system},
};
lib/Chem/Structure/Parser.pm view on Meta::CPAN
│ │ ├── molecule 'GROWTH HORMONE'
│ │ ├── chain [ 'A' ]
│ │ ├── engineered 'YES'
│ │ └── mutation 'YES'
│ └── 2 { molecule 'GROWTH HORMONE RECEPTOR', chain [ 'B' ],
│ fragment 'EXTRACELLULAR DOMAIN', engineered 'YES' }
├── source SOURCE, by MOL_ID
│ └── 1 { organism_scientific 'HOMO SAPIENS', organism_common
│ 'HUMAN', organism_taxid '9606', mol_id '1',
│ expression_system 'ESCHERICHIA COLI',
│ expression_system_taxid '562' }
├── entity_of_chain COMPND and SOURCE, by chain
│ ├── A { mol_id '1', molecule 'GROWTH HORMONE', fragment undef,
│ │ ec undef, organism 'HOMO SAPIENS', taxid '9606',
│ │ expressed_in 'ESCHERICHIA COLI' }
│ └── B { ..., fragment 'EXTRACELLULAR DOMAIN' }
├── seqres what SEQRES says was in the crystal
│ ├── A
│ │ ├── sequence 'FPTIPLSRLFDNAMLRAHRLHQLAFDTYQEFEEAYIPKEQKYSFLQ...'
│ │ ├── residues [ 'PHE', 'PRO', 'THR', 'ILE', ... ] 191 of them
│ │ └── length 191
lib/Chem/Structure/Parser.pm view on Meta::CPAN
│ ├── residue_types { amino_acid 180, water 26 }
│ ├── molecule 'GROWTH HORMONE' from COMPND
│ ├── organism 'HOMO SAPIENS' from SOURCE
│ ├── mol_id '1'
│ ├── dbref [ { ... } ] as in the top-level dbref
│ │ ec and fragment are here too, in a
│ │ chain whose file gives them
│ ├── residue_order [ '1', '2', '3', ... '574' ] file order, 206
│ └── residues keyed number + insertion code
│ ├── 54
│ │ ├── resname 'PHE'
Chemistry-Harmonia
view release on metacpan or search on metacpan
lib/Chemistry/Harmonia.pm view on Meta::CPAN
}
sub _in_gf{
my($s, $maU, $maUl, $cf) = @_;
# Unary symbols of fragment
my @i_maU = grep $s =~ /$_/i, @$maU;
if( length($s) == 1 ){ # Unary atom symbol
@i_maU || return;
$_ .= $i_maU[0] for @$cf;
return 1;
}
# Double symbols of fragment
( my @i_maUl = grep $s =~ /$_/i, @$maUl ) || @i_maU || return; # not present
# Strings of unary and double atom letters
my $saU = join '', @i_maU; # String of unary atom letters
my $saUl = join '|', @i_maUl; # 1th - CAPITAL, 2th - small
lib/Chemistry/Harmonia.pm view on Meta::CPAN
s/^$z//;
return &_in_gf($_, \@i_maU, \@i_maUl, $cf) if 3 > length;
}
}
if( @w ){ # Search by fragments of anchor symbols
my $m = join '|', @w;
for my $f (split /($m)/, $s){
&_in_gf($f, \@i_maU, \@i_maUl, $cf);
if( $#{$cf} ){ # For >1 formula
# To leave the longest fragments
for( my $i = $#$cf; $i > 0; $i-- ){
splice @$cf, $i, 1 if length( $cf->[$i] ) < length( $cf->[0] );
}
}
}
return 1;
}
# Difficult fragment
my $cf_copy = [ @$cf ];
$#{$cf} = -1; # Reset
_M_gf_1: # Letter by letter search
for( my $i = 1; $i < length($s); $i++ ){
lib/Chemistry/Harmonia.pm view on Meta::CPAN
my $cf_new = [ @$cf_copy ];
for( $s =~ /^(\w{$i})(\w+)/ ){
&_in_gf($_, \@i_maU, \@i_maUl, $cf_new) || next _M_gf_1;
}
# To accumulate only unique, big fragments
for my $k ( @$cf_new ){
scalar( grep length($_) > length($k) || $_ eq $k, @$cf ) || push @$cf, $k;
}
}
return 1;
Chemistry-Mol
view release on metacpan or search on metacpan
lib/Chemistry/Mol.pm view on Meta::CPAN
$mol;
}
=item my @mols = $mol->separate
Separates a molecule into "connected fragments". The original object is not
modified; the fragments are clones of the original ones. Example: if you have
ethane (H3CCH3) and you delete the C-C bond, you have two CH3 radicals within
one molecule object ($mol). When you call $mol->separate you get two molecules,
each one with a CH3.
=cut
# splits a molecule into connected fragments
# returns a list of molecules. Does not touch the original copy.
sub separate {
my ($self) = @_;
$self = $self->clone;
my $unseen = set($self->atoms);
Chemistry-OpenBabel
view release on metacpan or search on metacpan
openbabel_perl.cpp view on Meta::CPAN
int res2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
SWIG_croak("Usage: OBMol_FindLargestFragment(self,frag);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_OpenBabel__OBMol, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OBMol_FindLargestFragment" "', argument " "1"" of type '" "OpenBabel::OBMol *""'");
}
Chess-PGN-EPD
view release on metacpan or search on metacpan
lib/Chess/PGN/EPD.pm view on Meta::CPAN
<IMG SRC="jpc/wr.gif"><IMG SRC="jpc/wn.gif"><IMG SRC="jpc/wb.gif"><IMG SRC="jpc/wq.gif"><IMG
SRC="jpc/wk.gif"><IMG SRC="jpc/wb.gif"><IMG SRC="jpc/i.gif"><IMG SRC="jpc/wr.gif"><BR>
=item 'latex'
The necessary text fragment to 'set' the diagram in LaTeX using
any variation of Piet Tutelars original chess12.tar.Z package. As given, the LaTeX
command 'diagram' is used. As an example here is the source to test.tex:
%%
%% test.tex -- example LaTeX file to demonstrate output from Chess::PGN::EPD
lib/Chess/PGN/EPD.pm view on Meta::CPAN
\usepackage{chess}
\usepackage{bdfchess}
\begin{document}
\newenvironment{diagram}{\begin{nochess}}{$$\showboardwithnotation$$\end{nochess}}
%%
%% fragment as produced by epdstr(epd => $position,type => 'latex');
%%
\begin{diagram}
\board
{rnbqkb r}
{ppp pppp}
lib/Chess/PGN/EPD.pm view on Meta::CPAN
{* * * * }
{PPPP PPP}
{RNBQKBNR}
\end{diagram}
%%
%% end of fragment
%%
\end{document}
=item 'linares'
Chorus
view release on metacpan or search on metacpan
agent/skills/chorus-feed.md view on Meta::CPAN
- Add required helpers to `Helpers.pm`
- Verify that new slots do not conflict with those
of other agents (Slot dictionary of the index)
**New domain case:**
- Apply Mode A (Phases 1 to 5.5) on the fragment only
- Determine the position of the new agent in the pipeline:
- Does it read a slot set by an existing agent? → after it
- Does it set a slot consumed by an existing agent? → before it
- Update `index.org`: insert the new agent at the correct position
- âš Verify that the insertion does not break the chain of targeting slots
Cindy
view release on metacpan or search on metacpan
lib/Cindy.pm view on Meta::CPAN
if (!$dont_omit) {
# Until HTML_PARSE_NOIMPLIED is implemented by
# libxml2 (and passed by XML::LibXML) we need
# to remove html/body tags that have been added to
# fragments.
omit_nodes($doc, 'html');
omit_nodes($doc, 'body');
}
return $doc;
}
lib/Cindy.pm view on Meta::CPAN
<source> repeat <target> [condition] {
<actions>
} ;
The optional condition is an xpath expression that is run in the context
of the root node of a temporary document fragment. The fragment has
two children, DOC and DATA which hold a subtree from a repeat doc respective data
match. Only those combinations where the condition evaluates to true are
used, all others are discarded.
Note that the repeat condition is an EXPERIMENTAL feature, it may well
Cisco-Regex
view release on metacpan or search on metacpan
|
(?:lt\s+(?:$port|$pnames))
|
(?:gt\s+(?:$port|$pnames))
|
(?:ack|dscp|established|fin|fragments|psh|rst|syn|urg)
}x;
my $standard = qr{
^access-list
\s+
Cisco-SNMP
view release on metacpan or search on metacpan
lib/Cisco/SNMP/IP.pm view on Meta::CPAN
$ips->ipReasmFails();
Return the IP reassembly fails of the device.
=head3 ipFragOKs() - return IP fragments OK
$ips->ipFragOKs();
Return the IP fragments OK of the device.
=head3 ipFragFails() - return IP fragment fails
$ips->ipFragFails();
Return the IP fragment fails of the device.
=head3 ipFragCreates() - return IP fragment creates
$ips->ipFragCreates();
Return the IP fragment creates of the device.
=head2 ip_forwardingOn - enable IP forwarding
$cm->ip_forwardingOn;
Clang
view release on metacpan or search on metacpan
t/01-tunit.t
t/02-cursor.t
t/03-cursorkind.t
t/05-typekind.t
t/06-diagnostic.t
t/fragments/animal.h
t/fragments/cat.cc
t/fragments/cat.h
t/fragments/main.cpp
t/fragments/mammal.h
t/fragments/person.cpp
t/fragments/person.h
t/fragments/test.c
t/release-check-manifest.t
t/release-pod-coverage.t
t/release-pod-syntax.t
typemap
xs/Cursor.xs
ClarID-Tools
view release on metacpan or search on metacpan
share/icd10.json view on Meta::CPAN
"B9623": "Unspecified Shiga toxin-producing Escherichia coli [E. coli] [STEC] as the cause of diseases classified elsewhere",
"B9629": "Other Escherichia coli [E. coli] as the cause of diseases classified elsewhere",
"B963": "Hemophilus influenzae [H. influenzae] as the cause of diseases classified elsewhere",
"B964": "Proteus (mirabilis) (morganii) as the cause of diseases classified elsewhere",
"B965": "Pseudomonas (aeruginosa) (mallei) (pseudomallei) as the cause of diseases classified elsewhere",
"B966": "Bacteroides fragilis [B. fragilis] as the cause of diseases classified elsewhere",
"B967": "Clostridium perfringens [C. perfringens] as the cause of diseases classified elsewhere",
"B968": "Other specified bacterial agents as the cause of diseases classified elsewhere",
"B9681": "Helicobacter pylori [H. pylori] as the cause of diseases classified elsewhere",
"B9682": "Vibrio vulnificus as the cause of diseases classified elsewhere",
"B9683": "Acinetobacter baumannii as the cause of diseases classified elsewhere",
share/icd10.json view on Meta::CPAN
"H5901": "Keratopathy (bullous aphakic) following cataract surgery",
"H59011": "Keratopathy (bullous aphakic) following cataract surgery, right eye",
"H59012": "Keratopathy (bullous aphakic) following cataract surgery, left eye",
"H59013": "Keratopathy (bullous aphakic) following cataract surgery, bilateral",
"H59019": "Keratopathy (bullous aphakic) following cataract surgery, unspecified eye",
"H5902": "Cataract (lens) fragments in eye following cataract surgery",
"H59021": "Cataract (lens) fragments in eye following cataract surgery, right eye",
"H59022": "Cataract (lens) fragments in eye following cataract surgery, left eye",
"H59023": "Cataract (lens) fragments in eye following cataract surgery, bilateral",
"H59029": "Cataract (lens) fragments in eye following cataract surgery, unspecified eye",
"H5903": "Cystoid macular edema following cataract surgery",
"H59031": "Cystoid macular edema following cataract surgery, right eye",
"H59032": "Cystoid macular edema following cataract surgery, left eye",
"H59033": "Cystoid macular edema following cataract surgery, bilateral",
"H59039": "Cystoid macular edema following cataract surgery, unspecified eye",
share/icd10.json view on Meta::CPAN
"Q95": "Balanced rearrangements and structural markers, not elsewhere classified",
"Q950": "Balanced translocation and insertion in normal individual",
"Q951": "Chromosome inversion in normal individual",
"Q952": "Balanced autosomal rearrangement in abnormal individual",
"Q953": "Balanced sex/autosomal rearrangement in abnormal individual",
"Q955": "Individual with autosomal fragile site",
"Q958": "Other balanced rearrangements and structural markers",
"Q959": "Balanced rearrangement and structural marker, unspecified",
"Q96": "Turner's syndrome",
"Q960": "Karyotype 45, X",
"Q961": "Karyotype 46, X iso (Xq)",
share/icd10.json view on Meta::CPAN
"Y36140": "War operations involving destruction of aircraft due to accidental detonation of onboard munitions and explosives, military personnel",
"Y36141": "War operations involving destruction of aircraft due to accidental detonation of onboard munitions and explosives, civilian",
"Y3619": "War operations involving other destruction of aircraft",
"Y36190": "War operations involving other destruction of aircraft, military personnel",
"Y36191": "War operations involving other destruction of aircraft, civilian",
"Y362": "War operations involving other explosions and fragments",
"Y3620": "War operations involving unspecified explosion and fragments",
"Y36200": "War operations involving unspecified explosion and fragments, military personnel",
"Y36201": "War operations involving unspecified explosion and fragments, civilian",
"Y3621": "War operations involving explosion of aerial bomb",
"Y36210": "War operations involving explosion of aerial bomb, military personnel",
"Y36211": "War operations involving explosion of aerial bomb, civilian",
"Y3622": "War operations involving explosion of guided missile",
"Y36220": "War operations involving explosion of guided missile, military personnel",
share/icd10.json view on Meta::CPAN
"Y36230": "War operations involving explosion of improvised explosive device [IED], military personnel",
"Y36231": "War operations involving explosion of improvised explosive device [IED], civilian",
"Y3624": "War operations involving explosion due to accidental detonation and discharge of own munitions or munitions launch device",
"Y36240": "War operations involving explosion due to accidental detonation and discharge of own munitions or munitions launch device, military personnel",
"Y36241": "War operations involving explosion due to accidental detonation and discharge of own munitions or munitions launch device, civilian",
"Y3625": "War operations involving fragments from munitions",
"Y36250": "War operations involving fragments from munitions, military personnel",
"Y36251": "War operations involving fragments from munitions, civilian",
"Y3626": "War operations involving fragments of improvised explosive device [IED]",
"Y36260": "War operations involving fragments of improvised explosive device [IED], military personnel",
"Y36261": "War operations involving fragments of improvised explosive device [IED], civilian",
"Y3627": "War operations involving fragments from weapons",
"Y36270": "War operations involving fragments from weapons, military personnel",
"Y36271": "War operations involving fragments from weapons, civilian",
"Y3629": "War operations involving other explosions and fragments",
"Y36290": "War operations involving other explosions and fragments, military personnel",
"Y36291": "War operations involving other explosions and fragments, civilian",
"Y363": "War operations involving fires, conflagrations and hot substances",
"Y3630": "War operations involving unspecified fire, conflagration and hot substance",
"Y36300": "War operations involving unspecified fire, conflagration and hot substance, military personnel",
"Y36301": "War operations involving unspecified fire, conflagration and hot substance, civilian",
"Y3631": "War operations involving gasoline bomb",
share/icd10.json view on Meta::CPAN
"Y37140": "Military operations involving destruction of aircraft due to accidental detonation of onboard munitions and explosives, military personnel",
"Y37141": "Military operations involving destruction of aircraft due to accidental detonation of onboard munitions and explosives, civilian",
"Y3719": "Military operations involving other destruction of aircraft",
"Y37190": "Military operations involving other destruction of aircraft, military personnel",
"Y37191": "Military operations involving other destruction of aircraft, civilian",
"Y372": "Military operations involving other explosions and fragments",
"Y3720": "Military operations involving unspecified explosion and fragments",
"Y37200": "Military operations involving unspecified explosion and fragments, military personnel",
"Y37201": "Military operations involving unspecified explosion and fragments, civilian",
"Y3721": "Military operations involving explosion of aerial bomb",
"Y37210": "Military operations involving explosion of aerial bomb, military personnel",
"Y37211": "Military operations involving explosion of aerial bomb, civilian",
"Y3722": "Military operations involving explosion of guided missile",
"Y37220": "Military operations involving explosion of guided missile, military personnel",
share/icd10.json view on Meta::CPAN
"Y37230": "Military operations involving explosion of improvised explosive device [IED], military personnel",
"Y37231": "Military operations involving explosion of improvised explosive device [IED], civilian",
"Y3724": "Military operations involving explosion due to accidental detonation and discharge of own munitions or munitions launch device",
"Y37240": "Military operations involving explosion due to accidental detonation and discharge of own munitions or munitions launch device, military personnel",
"Y37241": "Military operations involving explosion due to accidental detonation and discharge of own munitions or munitions launch device, civilian",
"Y3725": "Military operations involving fragments from munitions",
"Y37250": "Military operations involving fragments from munitions, military personnel",
"Y37251": "Military operations involving fragments from munitions, civilian",
"Y3726": "Military operations involving fragments of improvised explosive device [IED]",
"Y37260": "Military operations involving fragments of improvised explosive device [IED], military personnel",
"Y37261": "Military operations involving fragments of improvised explosive device [IED], civilian",
"Y3727": "Military operations involving fragments from weapons",
"Y37270": "Military operations involving fragments from weapons, military personnel",
"Y37271": "Military operations involving fragments from weapons, civilian",
"Y3729": "Military operations involving other explosions and fragments",
"Y37290": "Military operations involving other explosions and fragments, military personnel",
"Y37291": "Military operations involving other explosions and fragments, civilian",
"Y373": "Military operations involving fires, conflagrations and hot substances",
"Y3730": "Military operations involving unspecified fire, conflagration and hot substance",
"Y37300": "Military operations involving unspecified fire, conflagration and hot substance, military personnel",
"Y37301": "Military operations involving unspecified fire, conflagration and hot substance, civilian",
"Y3731": "Military operations involving gasoline bomb",
share/icd10.json view on Meta::CPAN
"Y381": "Terrorism involving destruction of aircraft",
"Y381X": "Terrorism involving destruction of aircraft",
"Y381X1": "Terrorism involving destruction of aircraft, public safety official injured",
"Y381X2": "Terrorism involving destruction of aircraft, civilian injured",
"Y381X3": "Terrorism involving destruction of aircraft, terrorist injured",
"Y382": "Terrorism involving other explosions and fragments",
"Y382X": "Terrorism involving other explosions and fragments",
"Y382X1": "Terrorism involving other explosions and fragments, public safety official injured",
"Y382X2": "Terrorism involving other explosions and fragments, civilian injured",
"Y382X3": "Terrorism involving other explosions and fragments, terrorist injured",
"Y383": "Terrorism involving fires, conflagration and hot substances",
"Y383X": "Terrorism involving fires, conflagration and hot substances",
"Y383X1": "Terrorism involving fires, conflagration and hot substances, public safety official injured",
"Y383X2": "Terrorism involving fires, conflagration and hot substances, civilian injured",
"Y383X3": "Terrorism involving fires, conflagration and hot substances, terrorist injured",
share/icd10.json view on Meta::CPAN
"Z17410": "Hormone receptor positive with human epidermal growth factor receptor 2 positive status",
"Z17411": "Hormone receptor positive with human epidermal growth factor receptor 2 negative status",
"Z1742": "Hormone receptor negative",
"Z17420": "Hormone receptor negative with human epidermal growth factor receptor 2 positive status",
"Z17421": "Hormone receptor negative with human epidermal growth factor receptor 2 negative status",
"Z18": "Retained foreign body fragments",
"Z180": "Retained radioactive fragments",
"Z1801": "Retained depleted uranium fragments",
"Z1809": "Other retained radioactive fragments",
"Z181": "Retained metal fragments",
"Z1810": "Retained metal fragments, unspecified",
"Z1811": "Retained magnetic metal fragments",
"Z1812": "Retained nonmagnetic metal fragments",
"Z182": "Retained plastic fragments",
"Z183": "Retained organic fragments",
"Z1831": "Retained animal quills or spines",
"Z1832": "Retained tooth",
"Z1833": "Retained wood fragments",
"Z1839": "Other retained organic fragments",
"Z188": "Other specified retained foreign body",
"Z1881": "Retained glass fragments",
"Z1883": "Retained stone or crystalline fragments",
"Z1889": "Other specified retained foreign body fragments",
"Z189": "Retained foreign body fragments, unspecified material",
"Z19": "Hormone sensitivity malignancy status",
"Z191": "Hormone sensitive malignancy status",
"Z192": "Hormone resistant malignancy status",
"Z20": "Contact with and (suspected) exposure to communicable diseases",
"Z200": "Contact with and (suspected) exposure to intestinal infectious diseases",
Class-Accessor-Fast-WithBuilder
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
return 1;
}
sub postamble {
$PostambleUsed = 1;
my $fragment;
$fragment .= <<"AUTO_INSTALL" if !$InstallDepsTarget;
config :: installdeps
\t\$(NOECHO) \$(NOOP)
AUTO_INSTALL
$fragment .= <<"END_MAKE";
checkdeps ::
\t\$(PERL) $0 --checkdeps
installdeps ::
inc/Module/AutoInstall.pm view on Meta::CPAN
listalldeps ::
\t$PostambleActionsListAllDeps
END_MAKE
return $fragment;
}
1;
__END__
Class-Accessor-Grouped
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
{
package MY;
sub distdir {
my ($self, @arg) = @_;
my $frag = $self->SUPER::distdir(@arg);
$frag =~ s/^(distdir\s*:.*)/$1 create_readme/m;
$frag .= <<'END_MAKE';
create_readme: create_distdir
pod2text lib/Class/Accessor/Grouped.pm > $(DISTVNAME)/README
cd $(DISTVNAME) && $(PERLRUN) "-MExtUtils::Manifest=maniadd" -e "maniadd({ README => 'Generated README' })"
END_MAKE
$frag;
}
}
use Text::ParseWords;
Class-Accessor-Lite
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
return 1;
}
sub postamble {
$PostambleUsed = 1;
my $fragment;
$fragment .= <<"AUTO_INSTALL" if !$InstallDepsTarget;
config :: installdeps
\t\$(NOECHO) \$(NOOP)
AUTO_INSTALL
$fragment .= <<"END_MAKE";
checkdeps ::
\t\$(PERL) $0 --checkdeps
installdeps ::
inc/Module/AutoInstall.pm view on Meta::CPAN
listalldeps ::
\t$PostambleActionsListAllDeps
END_MAKE
return $fragment;
}
1;
__END__
Class-AutoDB
view release on metacpan or search on metacpan
t/autodbUtil.pm view on Meta::CPAN
report_pass($ok,$label);
}
sub _cmp_thawed {
my($actual_objects,$correct_thawed,$label,$file,$line)=@_;
my @actual_thawed=grep {'Class::AutoDB::Oid' ne ref $_} @$actual_objects;
# unthawed objects are fragile and esily thawed. do the cmp this way to avoid thawing
my @actual_refs=
uniq map {ref($_).'='.Scalar::Util::reftype($_).sprintf('(%0x)',Scalar::Util::refaddr($_))}
@actual_thawed;
my @correct_refs=
uniq map {ref($_).'='.Scalar::Util::reftype($_).sprintf('(%0x)',Scalar::Util::refaddr($_))}
Class-Classgen-classgen
view release on metacpan or search on metacpan
Comments.pm view on Meta::CPAN
sub repair_header { # to put in missing ';' in the header section
my (@code) = @_; # the code edited into the header section
my @code2;
shift @code; # remove fragment
foreach (@code) {
# next if( $_=~m/:/); # this is an identifier for the sect.
unless ( $_=~m/;/ ) { # then find insertion point
if($_=~m/#/){ # case where comment is present
$_=m/(^.*)(\s*)#(.*)/;
Class-Classless-DBI
view release on metacpan or search on metacpan
lib/Class/Classless/DBI.pm view on Meta::CPAN
=head2 C<make_where_clause>
=head2 C<make_from_clause>
These methods are used internally by the previous methods but are also available
for public use. They generate fragments of SQL queries to be used with
L<SQL::Interpolate>. C<make_where_clause> expects the where key to be present in
the same format as specified above. C<make_from_clause> expects a key named from
in the same format as values in a C<insert_into_table> method call. Both accept
the columns key as well.
Class-DBI
view release on metacpan or search on metacpan
lib/Class/DBI.pm view on Meta::CPAN
#----------------------------------------------------------------------
# CONSTRUCTORS
#----------------------------------------------------------------------
sub add_constructor {
my ($class, $method, $fragment) = @_;
return $class->_croak("constructors needs a name") unless $method;
no strict 'refs';
my $meth = "$class\::$method";
return $class->_carp("$method already exists in $class")
if *$meth{CODE};
*$meth = sub {
my $self = shift;
$self->sth_to_objects($self->sql_Retrieve($fragment), \@_);
};
}
sub sth_to_objects {
my ($class, $sth, $args) = @_;
lib/Class/DBI.pm view on Meta::CPAN
WHERE year > ?
});
For such 'SELECT' queries L<Ima::DBI>'s set_sql() method is extended to
create a helper shortcut method, named by prefixing the name of the
SQL fragment with 'search_'. Thus, the above call to set_sql() will
automatically set up the method Music::CD->search_new_music(), which
will execute this search and return the relevant objects or Iterator.
(If there are placeholders in the query, you must pass the relevant
arguments when calling your search method.)
lib/Class/DBI.pm view on Meta::CPAN
# .. then ..
my $count = $class->sql_count_above('year')->select_val(2001);
=head3 sql_single
Internally Class::DBI defines a very simple SQL fragment called 'single':
"SELECT %s FROM __TABLE__".
This is used to implement the above Class->count_all():
( run in 2.308 seconds using v1.01-cache-2.11-cpan-364913b4093 )