CPAN::Groonga

t($file)->mtime;
    if ( ( !$force ) and $mtime ~~ $mtimes{$file}->{mtime} ) {
        next;
    }

    if ( ( !$force ) and get_digest($file) ~~ $mtimes{$file}->{digest} ) {
        next;
   

(SvOBJECT(r)) { /* a ~~ $object */
            /* XXX: what I should do? */
            return tx_sv_eq_nomg(aTHX_ a, b);
        }
        else if(SvTYPE(r) == SVt_PVAV) { /* a ~~ [ ... ] */
        

 }
            }
            return FALSE;
        }
        else if(SvTYPE(r) == SVt_PVHV) { /* a ~~ { ... } */
            if(SvOK(a)) {
                HV* const hv = (HV*)r;
                return

return 'null' unless defined $v && $v ne 'undef';
	return $v if $self->field && $self->field->type ~~ [qw/int bigint serial bigserial numeric/];
	$v =~ s/'/''/g;
	$v =~ s!\\!\\\\!g;
	return "E'$v'";
}

f = shift;
	my $in = shift;
	my $out;
	my $type = ref $in;
	given($type) {
		when('SCALAR') {
			$out = $$in;
			if(defined($out) && $out ~~ /^-?\d+(?:\.\d+)?$/) {
				$out = $out+0;
			}
		}
		defaul

cut

sub decantQuotedValue {
	my $self = shift;
	my $in = shift;
	my $out;
	my $type = ref $in;
	given($type) {
		when('SCALAR') {
			$out = $$in;
			if(!defined($out)) {
				$out = 'NULL';
			} elsif

hile(my ($k, $v) = each %args) {
		if($k eq 'create') {
			$opt{create} = $v ? 1 : 0;
		} elsif($k ~~ $class->_supported_callbacks) {
			$self->{_callback}->{$k} = $v;
		} else {
			warn "Unknown call

$code", $event);
		push @{$self->{event_handler}->{$event}}, $code;
		++$self->{pending} if $event ~~ [qw(item done)];
	}
	return $self;
}

=head2 has_event_handlers_for

Returns how many event handle

(sort values %{$EntityMap{$args{entity}->name}->{store}}) {
		next ENTRY unless all { $entry->{$_} ~~ $args{data}->{$_} } keys %{$args{data}};
		++$seen;
		$args{on_item}->($entry) if exists $args{on_

dst->name;
	return 0 if $self->field->count != $dst->field->count;
	return 0 unless $self->primary ~~ $dst->primary;

	my @srcF = sort { $a->name cmp $b->name } $self->field->list;
	my @dstF = sort { 

%read = %$data;
		$fail->("wrong keys returned: " . join ',', keys %read) unless [sort keys %read] ~~ [qw(id name)];
		$fail->("wrong data for name -  returned: " . $read{name}) unless $read{name} eq 

_CALL, /* $foo.^methods */
    PVIP_NODE_REGEXP,
    PVIP_NODE_SMART_MATCH, /* ~~ */
    PVIP_NODE_NOT_SMART_MATCH, /* !~~ */
    PVIP_NODE_PERL5_REGEXP, /* m:P5/./ */
    PVIP_NODE_TRUE,
    PVIP_NOD

proferred\n";

        next if defined $mopt{include} && !( $pkg ~~ $mopt{include} );
        next if defined $mopt{exclude} && $pkg ~~ $mopt{exclude};

        # print STDERR "package $pkg accepted\n

cification>

Check the package name against the I<specification> using the smart match
operator (C<~~>) and ignore it if it does not match.  If C<-inner> or
C<-only_inner> are specified, inner package

cification>

Check the package name against the I<specification> using the smart
match operator (C<~~>) and ignore it if it matches.  The C<-exclude> match is
processed after C<-include> if both are s

_CALL, /* $foo.^methods */
    PVIP_NODE_REGEXP,
    PVIP_NODE_SMART_MATCH, /* ~~ */
    PVIP_NODE_NOT_SMART_MATCH, /* !~~ */
    PVIP_NODE_PERL5_REGEXP, /* m:P5/./ */
    PVIP_NODE_TRUE,
    PVIP_NOD

    my @v = map { $modem_api->get_modem_property( $mob, $_ ) } @match_keys;
                    @v ~~ @match_values;
                },
                $modem_api->get_modems()
                       

  $rrlp_resp_pdu->{referenceNumber} = $rrlp_pdu->{referenceNumber};
    my $rrlp_resp_type;

    given ( $rrlp_pdu->{component}->{present} )
    {
        when ($Net::Radio::Location::SUPL::XSc::RRLP_

 $log->debugf( "pdu: %s", $supl_pdu->xml_dump() );

    # decode_ulp_pdu croaks on error ...
    given ( $supl_pdu->{message}->{present} )
    {
        when ($Net::Radio::Location::SUPL::XSc::UlpMess

                                    # available
                                    return \$given ~~ \$_->{features}->{$entry};
                            } else {
                                  

           }";
                eval $eval_string; ## no critic
        }
        if ( not grep {$_ ~~ /hostname/} @functions ) {
                eval '
                sub hostname (;$) ## no critic (

                           # available
                                              return $given ~~ $_->{features}->{hostname};
                                      } else {
                       

if data is incorrect.

=item Anything else

Data's value must magically match rule's value (with C<~~> operator).

=back

Optional third argument (C<$overrule>) must be a coderef. It will be called wi

nless ref $data eq $rule;
        $result = $data;
    } else {
        die 'INVALID' unless $data ~~ $rule;
        $result = $data;
    }

    if ($overrule)
    {
        local $_ = $result;
      

iants) = @_;
    return sub {
        return unless ref $_ eq 'ARRAY';
        my @items = grep $_ ~~ @variants, keys %{{ map { $_ => 1 } @$_ }};
        return \@items if scalar(@items) > 0;
    };
}

 operator, C<~~>, can be used in a variety of situations. Here
are a few examples:

    say "Yep" if $banana ~~ @fruits;    # is the element is present in the array?
    exit if $error ~~ %fatal;     

      # is the key present in the hash?
    function() if $condition ~~ True    # is the condition true?
    %my_hash ~~ %their_hash             # do the hashes have the same keyes?

Smart matching is

$a ~~ /foo/  { ... }     # true if $a contains "foo"

The C<//> matching operator is documented in L<doc:perlop>. It operators on
C<$_> by default, or can be bound to another variable using the C<~~>

itespaces with 1 whitespace

	return $value;
}

# Description:
# Returns useflag settings of the given (installed) package.
# @useflags=$pxs->getUseSettingsOfInstalledPackage("dev-perl/perl-5.8.8-r3")

queue} = PICA::Modification::Queue->new( $args{queue} )
        unless 'PICA::Modification::Queue' ~~ reftype $args{queue};
    
    $args{check} ||= 60;

    if (($args{via} // '') =~ /^https?:\/\//)

};
    }

    croak "missing 'via' parameter to retrieve PICA+ records from"
        unless 'CODE' ~~ reftype $args{via};

    bless \%args, $class;
}

sub get {
    my ($self, $id) = @_;
    my $requ

(time()-$self->{check});

    return $request if ($next cmp $last) == -1;

    $request->update( 0 ~~ $self->pending($request) ? 1 : 0 );
    $self->{queue}->update( $id => $request );
    $self->{que

            ($retval->{xen_package}) = grep { m!repository/packages/xen/builds! } @{ $precondition ~~ dpath '/host/preconditions//filename' };
                        push @{$retval->{test}}, get_test

cility.

=head2 get_test_list_from_precondition

Utility function to extract testprograms from a given (sub-) precondition.

=head2 get_testrun_overview

This function reads and parses all preconditio

s = ['group', 'matrix', 'cube', 'hypercube'];  # if you go past here, you've gone too far...

   given (reftype $tree) {
      # Common code for both HASHs and ARRAYs
      when (/HASH|ARRAY/) {
     

   # and all foreign keys that refer to it.
   elsif ($pkey) { $fk_list = [ grep { $colnames->{$_} ~~ /^$pkey$/ } keys %$colnames ]; }

   # If only FKT is given, then the result set contains all fore