view release on metacpan or search on metacpan
The value of this key contains the unique ID number for the system.
=item B<num_procs>
The value of this key contains the number of processors in the system.
=item B<proc_speed>
The value of this key contains the speed of the processors in the system.
=item B<proc_type>
The value of this key contains the processor type (PowerPC_POWER5)
=item B<total_ram>
The value of this key contains the total amount of RAM in the system, in megabytes.
view release on metacpan or search on metacpan
utils/datasetCreator/applyMaxThreshold.pl view on Meta::CPAN
chomp $val; #I'm not sure if this is necassary...probably not
$count{$cui1}+=$val;
}
#NOTE: do not update counts for $2, because in the case where order
#does not matter, the matrix will have been pre-processed to ensure
#the second cui will appear first in the key. In the case where order
#does matter we just shouldnt be counting it anyway
}
close IN;
view release on metacpan or search on metacpan
pregfree|||
prepend_elem|||
prepend_madprops|||
printbuf|||
printf_nocontext|||vn
process_special_blocks|||
ptr_table_clear||5.009005|
ptr_table_fetch||5.009005|
ptr_table_find|||n
ptr_table_free||5.009005|
ptr_table_new||5.009005|
view release on metacpan or search on metacpan
examples/amfclient.pl view on Meta::CPAN
# unbless object
*$foo = sub {
my $f = $_[0];
#process_amf_object ($f, $amf_class);
+{ %{$f} };
}
} (
# add your own remote service classes here - or use an SWFDecompiler
view release on metacpan or search on metacpan
lib/AMF/Perl.pm view on Meta::CPAN
}
sub log
{
my ($self, $content) = @_;
$self->_appendRawDataToFile ($self->debugDir."processing.txt",$content."\n");
}
1;
__END__
view release on metacpan or search on metacpan
# do right now, and good enough for this little routing table.
my($out, $cmd);
$cmd = "LANG=C $routebin route del $rkey";
$out = `$cmd 2>&1`;
if ($?) {
if ($verbose > 1 || $out !~ /No such process/) {
warn "route del failed: '$cmd': $out\n";
}
}
}
if ($?) {
warn "route add failed: '$cmd': $out\n";
}
}
# process a RIPv2 password authentication entry
sub process_rip_auth_entry($)
{
my($entry) = @_;
my $e_af = unpack('n', substr($entry, 0, 2));
if ($e_af != 0xFFFF) {
}
return (1, 'ok');
}
# process a RIPv2 route entry
sub process_rip_route_entry($)
{
my($entry) = @_;
my $e_af = unpack('n', substr($entry, 0, 2));
my $e_rtag = unpack('n', substr($entry, 2, 2));
if ($e_af == 0xFFFF) {
process_rip_auth_entry($entry);
return -1;
}
if ($e_af != AF_INET) {
warn "$me: RIPv2 entry has unsupported AF $e_af\n";
consider_route($e_net_s, $e_netmask_s, $e_nexthop_s, $e_rtag);
return 1;
}
# process a RIP message
sub process_msg($$$)
{
my($addr_s, $perr_port, $msg) = @_;
# validate packet's length
if (length($msg) < RIP_HDR_LEN + RIP_ENTRY_LEN) {
my $init_msg = 0;
# if password auth is required, require it!
if (defined $rip_passwd) {
return -1 if (!process_rip_auth_entry(substr($entries, 0, RIP_ENTRY_LEN)));
$init_msg += RIP_ENTRY_LEN;
}
# Ok, process the actual route entries
my $routes = 0;
for (my $i = $init_msg; $i < length($entries); $i += RIP_ENTRY_LEN) {
my $entry = substr($entries, $i, RIP_ENTRY_LEN);
my $n = process_rip_route_entry($entry);
return -1 if ($n < 0);
$routes += $n;
}
return $routes;
my $expire_interval = 60*60;
my $next_expire = time() + $expire_interval;
# Main loop: receive broadcasts, check that they're from the correct
# address and port, and pass them on to processing
warn "entering main loop, waiting for RIPv2 datagrams\n" if ($verbose);
while (1) {
my $msg;
my $remote_address = recv($socket, $msg, 1500, 0);
next;
}
warn "received from $addr_s: $peer_port: " . length($msg) . " bytes\n" if ($verbose);
my $routes = process_msg($addr_s, $peer_port, $msg);
warn "processed $routes route entries\n" if ($verbose && $routes >= 0);
# Consider expiring old routes. This is actually never run if we do not receive
# any RIP broadcasts at all (the recv() is blocking)
# The (desired) side effect is that if the RIP announcer
# dies, the entries do not time out.
view release on metacpan or search on metacpan
lib/ANSI/Heatmap.pm view on Meta::CPAN
X co-ordinate.
=head2 render ( DATA )
Manually render heatmap data as returned by C<data>. Useful
if you want to do any custom processing.
=head2 swatch ( [ARRAYREF | STRING] )
Set the colour swatch that decided how the heatmap will look.
A string alias can be provided, or an arrayref of numeric values
view release on metacpan or search on metacpan
$TOC_VERSION = "1.0";
$ROASTING_KEY = "Tic/Toc";
# Preloaded methods go here.
# Autoload methods go after =cut, and are processed by the autosplit program.
=head1 NAME
AOL::TOC - Perl extension for interfacing with AOL's AIM service
view release on metacpan or search on metacpan
lib/API/BigBlueButton/Requests.pm view on Meta::CPAN
package API::BigBlueButton::Requests;
=head1 NAME
API::BigBlueButton::Requests - processing of API requests
=cut
use 5.008008;
use strict;
view release on metacpan or search on metacpan
lib/API/CPanel.pm view on Meta::CPAN
return $deparsed ? $deparsed : '';
}
# Get + deparse
# STATIC(STRING: query_string)
sub process_query {
my %params = @_;
my $auth_hash = $params{auth_hash};
my $query_string = $params{query_string};
my $xml_parser_params = $params{parser_params} || '';
lib/API/CPanel.pm view on Meta::CPAN
%$params,
} );
warn Dumper $query_string if $DEBUG;
my $server_answer = process_query(
auth_hash => $auth_hash,
query_string => $query_string,
parser_params => $xml_parser_params,
);
warn Dumper $server_answer if $DEBUG;
view release on metacpan or search on metacpan
lib/API/Client.pm view on Meta::CPAN
$self->set_identity($ua, $tx, %args);
return $self;
}
method process(Object $ua, Object $tx, Any %args) {
return $self;
}
method resource(Str @segments) {
lib/API/Client.pm view on Meta::CPAN
# transaction retry loop
for (my $i = 0; $i < ($retries || 1); $i++) {
# execute transaction
$tx = $ua->start($ua->build_tx($method, $url, $headers, @args));
$self->process($ua, $tx, %args);
# transaction objects
$req = $tx->req;
$res = $tx->res;
lib/API/Client.pm view on Meta::CPAN
package main;
my $hookbin = Hookbin->new;
This package was designed to be subclassed and provides hooks into the client
building and request dispatching processes. Specifically, there are three
useful hooks (i.e. methods, which if present are used to build up the client
object and requests), which are, the C<auth> hook, which should return a
C<Tuple[Str, Str]> which is used to configure the basic auth header, the
C<base> hook which should return a C<Tuple[Str]> which is used to configure the
base URL, and the C<headers> hook, which should return a
lib/API/Client.pm view on Meta::CPAN
=back
=cut
=head2 process
process(Object $ua, Object $tx, Any %args) : Object
The process method acts as an C<after> hook triggered after each response where
you can modify the transactor objects.
=over 4
=item process example #1
# given: synopsis
require Mojo::UserAgent;
require Mojo::Transaction::HTTP;
$client->process(
Mojo::UserAgent->new,
Mojo::Transaction::HTTP->new
);
=back
view release on metacpan or search on metacpan
lib/API/DirectAdmin.pm view on Meta::CPAN
%$params,
} );
carp Dumper $query_string if $self->{debug};
my $server_answer = $self->process_query(
method => $params{method} || 'GET',
query_string => $query_string,
params => $params,
);
lib/API/DirectAdmin.pm view on Meta::CPAN
return $result;
}
# Get + deparse
# STATIC(STRING: query_string)
sub process_query {
my ( $self, %params ) = @_;
my $query_string = $params{query_string};
my $method = $params{method};
view release on metacpan or search on metacpan
lib/API/Eulerian/EDW/Hook.pm view on Meta::CPAN
#
# @file Hook.pm
#
# @brief Eulerian Data Warehouse Peer Hook Base class Module definition.
#
# This module is aimed to provide callback hooks userfull to process reply data.
# Library user can create is own Hook class conforming to this module interface
# to handle reply data in specific manner.
#
# @author Thorillon Xavier:x.thorillon@eulerian.com
#
lib/API/Eulerian/EDW/Hook.pm view on Meta::CPAN
API::Eulerian::EDW::Hook - Eulerian Data Warehouse Peer Hook module.
=head1 DESCRIPTION
This module provides callback hooks interface used to process analysis reply
data. Library user can create their own derived class matching this module
interface. It permits to process reply data in a specific manner.
=head1 METHODS
=head2 new()
view release on metacpan or search on metacpan
lib/API/INSEE/Sirene.pm $(INST_MAN3DIR)/API::INSEE::Sirene.$(MAN3EXT)
# --- MakeMaker processPL section:
# --- MakeMaker installbin section:
view release on metacpan or search on metacpan
lib/API/ISPManager.pm view on Meta::CPAN
return $deparsed ? $deparsed : '';
}
# Get + deparse
# STATIC(STRING: query_string)
sub process_query {
my %params = @_;
my $query_string = $params{query_string};
my $xml_parser_params = $params{parser_params} || '';
my $fake_answer = $params{fake_answer} || '';
lib/API/ISPManager.pm view on Meta::CPAN
return '' unless $query_string;
warn $query_string if $DEBUG;
my $xml = process_query( query_string => $query_string);
if ($xml) {
my $error_node = exists $xml->{authfail};
return '' if $error_node;
lib/API/ISPManager.pm view on Meta::CPAN
%$params,
} );
warn Dumper $query_string if $DEBUG;
return process_query(
query_string => $query_string,
parser_params => $xml_parser_params,
fake_answer => $fake_answer,
);
view release on metacpan or search on metacpan
CONTRIBUTING.md view on Meta::CPAN
```
$ dzil test
```
To run the full set of tests (including author and release-process tests),
add the `--author` and `--release` options:
```
$ dzil test --author --release
```
view release on metacpan or search on metacpan
lib/API/Mathpix.pm view on Meta::CPAN
my $mathpix = API::Mathpix->new({
app_id => $ENV{MATHPIX_APP_ID},
app_key => $ENV{MATHPIX_APP_KEY},
});
my $response = $mathpix->process({
src => 'https://mathpix.com/examples/limit.jpg',
});
print $response->text;
lib/API/Mathpix.pm view on Meta::CPAN
)
);
}
=head2 process
=cut
sub process {
my ($self, $opt) = @_;
if (-f $opt->{src}) {
view release on metacpan or search on metacpan
directory to install modules to. For details, see the local::lib documentation:
https://metacpan.org/pod/local::lib
The prerequisites of this distribution will also have to be installed manually. The
prerequisites are listed in one of the files: `MYMETA.yml` or `MYMETA.json` generated
by running the manual build process described above.
## Configure Prerequisites
This distribution requires other modules to be installed before this
distribution's installer can be run. They can be found under the
view release on metacpan or search on metacpan
lib/API/MikroTik/Sentence.pm view on Meta::CPAN
my $words = $sentence->fetch(\$buff);
Fetches a sentence from a buffer and parses it into a list of API words. In a
situation when amount of data in the buffer are insufficient to complete the
sentence, already processed words and the remaining buffer will be stored in an
object. On a next call will prepend a buffer with kept data and merge a result
with the one stored from a previous call.
=head2 is_incomplete
my $done = !$sentence->is_incomplete;
Indicates that a processed buffer was incomplete and remaining amount of data was
insufficient to complete a sentence.
=head2 reset
my $sentence->reset;
view release on metacpan or search on metacpan
lib/API/ParallelsWPB/Requests.pm view on Meta::CPAN
DEFAULT_TEMPLATE_CODE => 'generic',
DEFAULT_CREATE_SITE_STATE => 'trial',
DEFAULT_SESSIONLIFETIME => '1800',
};
# ABSTRACT: processing of API requests
our $VERSION = '0.03'; # VERSION
our $AUTHORITY = 'cpan:IMAGO'; # AUTHORITY
lib/API/ParallelsWPB/Requests.pm view on Meta::CPAN
=encoding UTF-8
=head1 NAME
API::ParallelsWPB::Requests - processing of API requests
=head1 VERSION
version 0.03
view release on metacpan or search on metacpan
lib/API/Plesk/Response.pm view on Meta::CPAN
__END__
=head1 NAME
API::Plesk::Response - Class for processing server answers with errors handling.
=head1 SYNOPSIS
my $res = API::Plesk::Response->new(
operator => 'customer',
lib/API/Plesk/Response.pm view on Meta::CPAN
$res->guid;
=head1 DESCRIPTION
This class is intended for convenient processing results of Plesk API responses.
Every operation of API::Plesk::Component return object of this class.
And it get you easy way to manipulate with response from Plesk API.
=head1 METHODS
view release on metacpan or search on metacpan
lib/APISchema.pm view on Meta::CPAN
};
# main.pl
use APISchema::DSL;
my $schema = APISchema::DSL::process {
include 'bmi.def';
};
# Routing
use APISchema::Generator::Router::Simple;
view release on metacpan or search on metacpan
lib/APNS/Agent.pm view on Meta::CPAN
B<THE SOFTWARE IS ALPHA QUALITY. API MAY CHANGE WITHOUT NOTICE.>
=head1 API PARAMETERS
APNS::Agent launches HTTP Server process which accepts only POST method and
C<application/x-www-form-urlencoded> format parameters.
Acceptable parameters as follows:
=over
view release on metacpan or search on metacpan
lib/APP/REST/RestTestSuite.pm view on Meta::CPAN
#START_HTTP_CODE_DEF
############################
200 : operation successful.
201 : Successful creation of a resource.
202 : The request was received.
204 : The request was processed successfully, but no response body is needed.
301 : Resource has moved.
303 : Redirection.
304 : Resource has not been modified.
400 : Malformed syntax or a bad query.
401 : Action requires user authentication.
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
}
close FH or die "close($_[0]): $!";
}
END_OLD
# _version is for processing module versions (eg, 1.03_05) not
# Perl versions (eg, 5.8.1).
sub _version ($) {
my $s = shift || 0;
my $d =()= $s =~ /(\.)/g;
if ( $d >= 2 ) {
view release on metacpan or search on metacpan
lib/Arc/Connection.pm view on Meta::CPAN
}
return $command; # There was an error if undef is return
}
## process an ARCv2 command. (protocol)
## Process a command by evaling $this->_R$cmd. Also checks if
## this command was expected now (looks into the $this->{_expectedcmds} array).
## Used by client and server.
##in> $cmd
##out> true, if ARCv2 command has been in place, otherwise false
view release on metacpan or search on metacpan
lib/ARGV/Abs.pm view on Meta::CPAN
From a script where B<all> arguments are expected to be filenames:
use ARG::Abs;
...
From a script that takes command-line options that should not be processed by
C<ARGV::Abs> :
# Skipping import
use ARGV::Abs ();
view release on metacpan or search on metacpan
lib/ARGV/URL.pm view on Meta::CPAN
use ARG::URL;
...
while (<>) {
...
From a script that takes command-line options that should not be processed by
C<ARGV::URL> :
# Skipping import
use ARGV::URL ();
view release on metacpan or search on metacpan
lib/ARGV/readonly.pm view on Meta::CPAN
=head1 TO DO
ideally a suite of ARGV::* modules will appear, each doing their little thing,
in a way that they won't stomp on each other's toes. This module has no
exclusion interface or anything, so an @ARGV modifier that, for instance,
preprocesses *.gz into C<"gunzip -c $_ |"> is either going to have to undo
the mods made here or be incompatible.
=head1 HISTORY
=over 8
view release on metacpan or search on metacpan
lib/ARS/Simple.pm view on Meta::CPAN
my ($self, $args) = @_;
my $qual = ars_LoadQualifier($self->{ctl}, $args->{form}, $args->{query});
unless ($qual)
{
$self->_carp("_load_qualifier() Error processing query:\n$ars_errstr\n");
}
return $qual;
}