Result:
found more than 625 distributions - search limited to the first 2001 files matching your query
( run in 0.921 )
Alt-Math-Prime-FastSieve-Inline
view release on metacpan or search on metacpan
inc/Inline/C.pm view on Meta::CPAN
my $junk = "";
my $current = \$junk;
while (<TYPEMAP>) {
next if /^\s*\#/;
my $line_no = $. + 1;
if (/^INPUT\s*$/) {$mode = 'Input'; $current = \$junk; next}
if (/^OUTPUT\s*$/) {$mode = 'Output'; $current = \$junk; next}
if (/^TYPEMAP\s*$/) {$mode = 'Typemap'; $current = \$junk; next}
if ($mode eq 'Typemap') {
chomp;
my $line = $_;
TrimWhitespace($_);
inc/Inline/C.pm view on Meta::CPAN
I32* temp;
CODE:
temp = PL_markstack_ptr++;
RETVAL = $function($arg_name_list);
PL_markstack_ptr = temp;
OUTPUT:
RETVAL
END
}
}
$XS .= "\n";
inc/Inline/C.pm view on Meta::CPAN
#define Inline_Stack_Vars dXSARGS
#define Inline_Stack_Items items
#define Inline_Stack_Item(x) ST(x)
#define Inline_Stack_Reset sp = mark
#define Inline_Stack_Push(x) XPUSHs(x)
#define Inline_Stack_Done PUTBACK
#define Inline_Stack_Return(x) XSRETURN(x)
#define Inline_Stack_Void XSRETURN(0)
#define INLINE_STACK_VARS Inline_Stack_Vars
#define INLINE_STACK_ITEMS Inline_Stack_Items
inc/Inline/C.pm view on Meta::CPAN
sub build_error_message {
my ($o, $cmd, $output_file, $build_noisy) = @_;
my $build_dir = $o->{API}{build_dir};
my $output = '';
if (not $build_noisy and
open(OUTPUT, $output_file)
) {
local $/;
$output = <OUTPUT>;
close OUTPUT;
}
my $errcode = $? >> 8;
$output .= <<END;
AltaVista-PerlSDK
view release on metacpan or search on metacpan
avs_addword(idx, pWords, loc, pNumWords)
avs_idxHdl_t idx
char *pWords
long loc
long &pNumWords
OUTPUT:
RETVAL
pNumWords
int
avs_buildmode(idx)
int
avs_compact(idx, bMore_p)
avs_idxHdl_t idx
int &bMore_p
OUTPUT:
RETVAL
bMore_p
int
avs_compactionneeded (idx)
int
avs_compact_minor(idx, bMore_p)
avs_idxHdl_t idx
int &bMore_p
OUTPUT:
RETVAL
bMore_p
int
avs_count(idx, pWordPrefix, pCountsHdl)
avs_idxHdl_t idx
char *pWordPrefix
avs_countsHdl_t &pCountsHdl = NO_INIT
OUTPUT:
pCountsHdl
RETVAL
int
avs_count_close(CountsHdl)
void
avs_default_options(pOptions)
avs_options_p_t pOptions
CODE:
avs_default_options(pOptions);
OUTPUT:
pOptions
int
avs_define_valtype(name, minval, maxval, valtype_p)
char * name
unsigned long minval
unsigned long maxval
avs_valtype_t valtype_p = NO_INIT
CODE:
RETVAL = avs_define_valtype(name, minval, maxval, NULL, &valtype_p);
OUTPUT:
RETVAL
valtype_p
int
avs_define_valtype_multiple(name, minval, maxval, numvalues, valtype_p)
unsigned long maxval
int numvalues
avs_valtype_t valtype_p = NO_INIT
CODE:
RETVAL = avs_define_valtype_multiple(name, minval, maxval, numvalues, NULL, &valtype_p);
OUTPUT:
RETVAL
valtype_p
int
avs_deletedocid(idx, pDocId, pCount)
avs_idxHdl_t idx
char *pDocId
int &pCount
OUTPUT:
RETVAL
pCount
int
avs_enddoc(idx)
int
avs_getmaxloc(idx, pMaxloc)
avs_idxHdl_t idx
long &pMaxloc
OUTPUT:
RETVAL
pMaxloc
int
avs_getsearchresults(searchHdl, resultNum)
RETVAL = avs_getsearchterms(psearchHdl, termNum, &p, &i);
if (RETVAL == 0) {
count = i;
term = strdup(p);
}
OUTPUT:
term
count
RETVAL
int
avs_getsearchversion(searchHdl, searchversion)
avs_searchHdl_t searchHdl
char * searchversion
OUTPUT:
searchversion
RETVAL
int
avs_licenseinfo(key, expDate, docLimit)
char *key
time_t &expDate
long &docLimit
OUTPUT:
RETVAL
expDate
docLimit
avs_valtype_t
avs_idxHdl_t idx = NO_INIT
PREINIT:
avs_parameters_t myparms = AVS_PARAMETERS_INIT;
CODE:
RETVAL = avs_open(parameters, path, mode, &idx);
OUTPUT:
idx
RETVAL
int
avs_querymode(idx)
avs_options_p_t pOptions
long &pDocsFound = NO_INIT;
long &pDocsReturned = NO_INIT;
long &pTermCount = NO_INIT;
avs_searchHdl_t &pSearchHdl = NO_INIT;
OUTPUT:
RETVAL
pDocsFound
pDocsReturned
pTermCount
pSearchHdl
char *searchsince
long &pDocsFound = NO_INIT;
long &pDocsReturned = NO_INIT;
long &pTermCount = NO_INIT;
avs_searchHdl_t &pSearchHdl = NO_INIT;
OUTPUT:
RETVAL
pDocsFound
pDocsReturned
pTermCount
pSearchHdl
CODE:
RETVAL = avs_search_genrank(idx, pBoolQuery, pRankTerms,
NULL, pOptions, searchsince,
&pDocsFound, &pDocsReturned,
&pSearchHdl);
OUTPUT:
pDocsFound
pDocsReturned
pSearchHdl
RETVAL
avs_search_getdate(psearchHdl, year, month, day)
avs_searchHdl_t psearchHdl
int &year
int &month
int &day
OUTPUT:
year
month
day
char *
PREINIT:
char *p;
CODE:
p = avs_search_getdocid(searchHdl);
RETVAL = strdup(p);
OUTPUT:
RETVAL
int
avs_search_getdocidlen(searchHdl)
avs_searchHdl_t searchHdl
float f;
CODE:
f = avs_search_getrelevance(psearchHdl);
sprintf(p, "%f", f);
RETVAL = strdup(p);
OUTPUT:
RETVAL
int
avs_setdocdata(idx, pDocData, len)
avs_idxHdl_t idx
char *pDocData
int len
CODE:
RETVAL = avs_setdocdata(idx, pDocData, len);
OUTPUT:
RETVAL
int
avs_setdocdate(idx, year, month, day)
avs_idxHdl_t idx
avs_startdoc(idx, pDocId, flags, pStartLoc)
avs_idxHdl_t idx
char *pDocId
int flags
long &pStartLoc
OUTPUT:
RETVAL
pStartLoc
void
avs_timer(current)
int
avs_total_docs(idx, pDoccount)
avs_idxHdl_t idx
long &pDoccount
OUTPUT:
RETVAL
pDoccount
AV *
avs_version(license_key)
while (*lines != 0) {
av_push(arr, newSVpv(strdup(*lines), 0));
lines++;
}
RETVAL = (AV *) arr;
OUTPUT:
RETVAL
avs_options_p_t
avs_create_options(limit, timeout, flags)
long limit
CODE:
RETVAL = malloc(sizeof(struct avs_options));
RETVAL->limit = limit;
RETVAL->timeout = timeout;
RETVAL->flags = flags;
OUTPUT:
RETVAL
avs_parameters_t *
avs_create_parameters(_interface_version, license, ignored_thresh, chars_before_wildcard, unlimited_wild_words, indexformat, cache_threshold, options, charset, ntiers, nbuckets)
char * _interface_version
RETVAL->cache_threshold = cache_threshold;
RETVAL->options = options;
RETVAL->charset = charset;
RETVAL->ntiers = ntiers;
RETVAL->nbuckets = nbuckets;
OUTPUT:
RETVAL
AltaVista-SDKLinguistics
view release on metacpan or search on metacpan
SDKLinguistics.xs view on Meta::CPAN
else
{
RETVAL = hdl;
}
}
OUTPUT:
RETVAL
char *
avsl_thesaurus_get(hdl, word, language, separator = ' ')
void *hdl
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
int
avsl_thesaurus_close(hdl)
SDKLinguistics.xs view on Meta::CPAN
}
RETVAL = err;
}
OUTPUT:
RETVAL
SDKLinguistics.xs view on Meta::CPAN
else
{
RETVAL = hdl;
}
}
OUTPUT:
RETVAL
char *
avsl_phrase_get(hdl, word, language, separator = ':')
void *hdl
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
int
avsl_phrase_close(hdl)
SDKLinguistics.xs view on Meta::CPAN
}
RETVAL = err;
}
OUTPUT:
RETVAL
void *
SDKLinguistics.xs view on Meta::CPAN
else
{
RETVAL = hdl;
}
}
OUTPUT:
RETVAL
char *
avsl_stem_get(hdl, word, language, separator = ' ')
void *hdl
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
int
avsl_stem_close(hdl)
SDKLinguistics.xs view on Meta::CPAN
}
RETVAL = err;
}
OUTPUT:
RETVAL
void *
avsl_spell_init(config)
SDKLinguistics.xs view on Meta::CPAN
else
{
RETVAL = hdl;
}
}
OUTPUT:
RETVAL
char *
avsl_spellcheck_get(hdl, word, language, separator = ' ')
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
char *
avsl_spellcorrection_get(hdl, word, language, separator = ' ')
void *hdl
SDKLinguistics.xs view on Meta::CPAN
RETVAL = 0;
}
}
}
OUTPUT:
RETVAL
int
avsl_spell_close(hdl)
SDKLinguistics.xs view on Meta::CPAN
}
RETVAL = err;
}
OUTPUT:
RETVAL
Alter
view release on metacpan or search on metacpan
CODE:
corona = ALT_corona(obj);
if (!corona)
XSRETURN_EMPTY;
RETVAL = newRV_inc((SV*)corona);
OUTPUT:
RETVAL
SV *alter(SV *obj, SV *val)
PROTOTYPE: $$
PREINIT:
if (!corona)
XSRETURN_EMPTY;
class = CopSTASHPV(PL_curcop);
hv_store(corona, class, strlen(class), SvREFCNT_inc(val), 0);
RETVAL = SvREFCNT_inc(obj); /* method chaining */
OUTPUT:
RETVAL
SV *ego(SV *obj, ...)
PROTOTYPE: $
CODE:
}
}
if (!ego)
XSRETURN_UNDEF;
RETVAL = SvREFCNT_inc(ego);
OUTPUT:
RETVAL
void _set_class_type(char *class, SV *spec)
CODE:
HV *type_tab = ALT_type_tab();
Alvis-Convert
view release on metacpan or search on metacpan
lib/Alvis/Convert.pm view on Meta::CPAN
$ERR_TYPE_SUFFIX,
$ERR_READ_HTML,
$ERR_READ_NEWS_XML,
$ERR_ALVIS_CONV,
$ERR_ALVIS_SUFFIX,
$ERR_NO_OUTPUT_ROOT_DIR,
$ERR_WRITING_OUTPUT,
$ERR_DIR_CONV,
$ERR_NO_HTML_F,
$ERR_META_F,
$ERR_HTML_F,
$ERR_NEWS_XML_F,
$ERR_DOC_ALVIS_CONV,
$ERR_NEWS_XML_PARSE,
$ERR_MULTIPLE_SUFFIX_MEANING,
$ERR_OUTPUT_ALVIS,
$ERR_OUTPUT_SET_OF_RECORDS,
$ERR_AINODUMP,
$ERR_OPEN_AINODUMP,
$ERR_AINODUMP_PROCESS,
$ERR_DOC_TYPE_WIZARD,
$ERR_TYPE_GUESS,
lib/Alvis/Convert.pm view on Meta::CPAN
$ERR_TYPE_SUFFIX=>"No suffix given for a type.",
$ERR_READ_HTML=>"Reading the HTML failed.",
$ERR_READ_NEWS_XML=>"Reading the news XML failed.",
$ERR_ALVIS_CONV=>"Conversion to Alvis format failed.",
$ERR_ALVIS_SUFFIX=>"No Alvis suffix defined.",
$ERR_NO_OUTPUT_ROOT_DIR=>"No output root directory.",
$ERR_WRITING_OUTPUT=>"Writing the output failed.",
$ERR_DIR_CONV=>"Converting a directory failed.",
$ERR_NO_HTML_F=>"No HTML file.",
$ERR_META_F=>"Opening the meta file failed.",
$ERR_HTML_F=>"Opening the HTML file failed.",
$ERR_NEWS_XML_F=>"Opening the news XML file failed.",
$ERR_DOC_ALVIS_CONV=>"Converting a document to Alvis format failed.",
$ERR_NEWS_XML_PARSE=>"Parsing the news XML failed.",
$ERR_MULTIPLE_SUFFIX_MEANING=>
"Multiple meanings for a single suffix.",
$ERR_OUTPUT_ALVIS=>"Outputting the Alvis records failed.",
$ERR_OUTPUT_SET_OF_RECORDS=>"Outputting a set of records to a " .
"file as a documentCollection failed.",
$ERR_AINODUMP=>"Instantiating Alvis::AinoDump failed.",
$ERR_OPEN_AINODUMP=>"Opening an ainodump file failed.",
$ERR_AINODUMP_PROCESS=>"Processing an ainodump file failed.",
$ERR_DOC_TYPE_WIZARD=>"Instantiating Alvis::Document::Type " .
lib/Alvis/Convert.pm view on Meta::CPAN
# _output_wikipedia_article($arg1,$arg2,...,
# $title,$output_format,
# $record_txt,$is_redir)
#
# where $output_format is a global defined in Alvis::Wikipedia::XMLDump
# as $OUTPUT_*
#
#
# progress_cb: [\&_wikipedia_progress,$arg1,$arg2,...] OPTIONAL
# will be called like this:
# _wikipedia_progress($arg1,$arg2,...,
lib/Alvis/Convert.pm view on Meta::CPAN
# namespaces ref to a list of namespace identifiers whose
# records to extract
# expandTemplates flag for true template expansion
# templateDumpF template dump file
# outputFormat format for result records
# ($Alvis::Wikipedia::XMLDump::OUTPUT_*)
# categoryWord category namespace identifier (changes with
# language)
# templateWord template namespace identifier (changes with
# language)
# rootCategory root category identifier (changes with
lib/Alvis/Convert.pm view on Meta::CPAN
$out_f=$base_name . "." . $self->{articleN} . '.' .
$self->{alvisSuffix};
$self->{articleN}++;
if (!$self->_output_set_of_records($alvis_record,$out_f))
{
$self->_set_err_state($ERR_OUTPUT_SET_OF_RECORDS);
return 0;
}
$self->{outputN}++;
print "$self->{outputN}\r";
}
else
{
if (!defined($self->{outputRootDir}))
{
$self->_set_err_state($ERR_NO_OUTPUT_ROOT_DIR);
return 0;
}
my $dir=$self->{outputRootDir} . '/' .
int($self->{outputN} / $self->{outputNPerSubdir});
if ($self->{outputN} % $self->{outputNPerSubdir}==0)
lib/Alvis/Convert.pm view on Meta::CPAN
$out_f=$dir . '/' . $self->{outputN} . '.' .
$self->{alvisSuffix};
if (!$self->_output_set_of_records($alvis_record,$out_f))
{
$self->_set_err_state($ERR_OUTPUT_SET_OF_RECORDS);
return 0;
}
$self->{outputN}++;
print "$self->{outputN}\r";
lib/Alvis/Convert.pm view on Meta::CPAN
return 0;
}
if (!$self->output_Alvis([$alvisXML],$base_name))
{
$self->_set_err_state($ERR_OUTPUT_ALVIS,
"Base name: \"$base_name\"");
return 0;
}
}
else
lib/Alvis/Convert.pm view on Meta::CPAN
my $set_of_records_txt=shift;
my $path=shift;
if (!defined(open(OUT,">:utf8",$path)))
{
$self->_set_err_state($ERR_WRITING_OUTPUT,"Output file: " .
"\"$path\"");
return 0;
}
print OUT "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
print OUT "<documentCollection xmlns=\"http://alvis.info/enriched/\">\n";
Alvis-NLPPlatform
view release on metacpan or search on metacpan
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
while(($j< scalar @cur_doc) && ($cur_doc[$j] !~ s/\@RENDER_TIME_NOT_SET\@/$render_time/)) {
$j++;
}
close(FILETMP_OUT);
if (!((exists $config->{"XML_OUTPUT"}->{"NO_STD_XML_OUTPUT"}) && ($config->{"XML_OUTPUT"}->{"NO_STD_XML_OUTPUT"} == 1))) {
if (scalar(@records) > 1) {
if ($i == 0){
pop @cur_doc;
} else {
shift @cur_doc;
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
print STDERR "\t" . $nlp_connection_vars{$var} . " : " . $config->{"NLP_connection"}->{$var} . "\n";
}
}
}
if (defined $config->{"XML_INPUT"}) {
print STDERR " Section Configuration of the XML INPUT\n";
my %xml_input_vars = ("PRESERVEWHITESPACE" => "Preserve XML White space?",
"LINGUISTIC_ANNOTATION_LOADING" => "Loading previous linguistic annotation?",
);
foreach $var (keys %xml_input_vars) {
if (defined $config->{"XML_INPUT"}->{$var}) {
print STDERR "\t" . $xml_input_vars{$var} . " : " . $config->{"XML_INPUT"}->{$var} . "\n";
}
}
}
if (defined $config->{"XML_OUTPUT"}) {
print STDERR " Section Configuration of the XML OUTPUT\n";
my %xml_output_vars = ("NO_STD_XML_OUTPUT" => "No printing standard XML output?",
);
foreach $var (keys %xml_output_vars) {
if (defined $config->{"XML_OUTPUT"}->{$var}) {
print STDERR "\t" . $xml_output_vars{$var} . " : " . $config->{"XML_OUTPUT"}->{$var} . "\n";
}
}
}
&compute_dependencies($config);
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
}
}
if (defined $config->{"CONVERTERS"}) {
print STDERR " Section INPUT CONVERTERS\n";
my %Converter_vars = ("SupplMagicFile" => "File for Additional Definition of Magic Number",
);
foreach $var (keys %Converter_vars) {
if (defined $config->{"CONVERTERS"}->{$var}) {
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
=over
=item * Global variables.
The two mandatory variables are C<ALVISTMP> and C<PRESERVEWHITESPACE>
(in the XML_INPUT section).
=over 8
=item *
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
C<RETRY_CONNECTION>: The number of times that
the clients attempts to connect to the server.
=back
=item * C<XML_INPUT>
=over 8
=item *
lib/Alvis/NLPPlatform.pm view on Meta::CPAN
=back
=item *
C<XML_OUTPUT> (Not available yet)
=over 8
=item *
C<NO_STD_XML_OUTPUT>: The standard XML output is not printed. Default
value is false.
=item
FORM
Amazon-CloudFront-Thin
view release on metacpan or search on metacpan
lib/Amazon/CloudFront/Thin.pm view on Meta::CPAN
sub _default_ua {
require LWP::UserAgent;
my $ua = LWP::UserAgent->new(
keep_alive => 10,
# requests_redirectable => [qw(GET HEAD DELETE PUT)]
);
$ua->timeout(10);
$ua->env_proxy;
return $ua;
}
Amazon-DynamoDB
view release on metacpan or search on metacpan
lib/Amazon/DynamoDB/20120810.pm view on Meta::CPAN
Key => {
user_id => 2
},
AttributeUpdates => {
name => {
Action => 'PUT',
Value => "Rusty Conover-3",
},
favorite_color => {
Action => 'DELETE'
},
Amazon-S3-Thin
view release on metacpan or search on metacpan
lib/Amazon/S3/Thin.pm view on Meta::CPAN
sub _default_ua {
my $self = shift;
my $ua = LWP::UserAgent->new(
keep_alive => 10,
requests_redirectable => [qw(GET HEAD DELETE PUT)],
);
$ua->timeout(30);
$ua->env_proxy;
return $ua;
}
lib/Amazon/S3/Thin.pm view on Meta::CPAN
sub copy_object {
my ($self, $src_bucket, $src_key, $dst_bucket, $dst_key, $headers) = @_;
$headers ||= {};
$headers->{'x-amz-copy-source'} = $src_bucket . "/" . $src_key;
my $request = $self->_compose_request('PUT', $self->_resource($dst_bucket, $dst_key), $headers);
my $res = $self->_send($request);
# XXX: Since the COPY request might return error response in 200 OK, we'll rewrite the status code to 500 for convenience
# ref http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html
# ref https://github.com/boto/botocore/blob/4e9b4419ec018716ab1a3fe1587fbdc3cfef200e/botocore/handlers.py#L77-L120
lib/Amazon/S3/Thin.pm view on Meta::CPAN
if (ref($content)) {
# TODO
# I do not understand what it is :(
#
# return $self->_send_request_expect_nothing_probed('PUT',
# $self->_resource($bucket, $key), $headers, $content);
#
die "unable to handle reference";
}
else {
my $request = $self->_compose_request('PUT', $self->_resource($bucket, $key), $headers, $content);
return $self->_send($request);
}
}
sub list_objects {
lib/Amazon/S3/Thin.pm view on Meta::CPAN
$content = <<"EOT";
<CreateBucketConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">$location_constraint</CreateBucketConfiguration>
EOT
}
my $request = $self->_compose_request('PUT', $self->_resource($bucket), $headers, $content);
return $self->_send($request);
}
sub delete_bucket {
my ($self, $bucket) = @_;
lib/Amazon/S3/Thin.pm view on Meta::CPAN
B<Arguments>: a list with source (bucket, key) and destination (bucket, key), hashref with extra header information (B<optional>).
B<Returns>: an L<HTTP::Response> object for the request.
This method is a variation of the PUT operation as described by
Amazon's S3 API. It creates a copy of an object that is already stored
in Amazon S3. This "PUT copy" operation is the same as performing a GET
from the old bucket/key and then a PUT to the new bucket/key.
Note that the COPY request might return error response in 200 OK, but this method
will determine the error response and rewrite the status code to 500.
For more information, please refer to
lib/Amazon/S3/Thin.pm view on Meta::CPAN
=back
B<Returns>: an L<HTTP::Response> object for the request.
The PUT operation adds an object to a bucket. Amazon S3 never adds partial
objects; if you receive a success response, Amazon S3 added the entire
object to the bucket.
For more information, please refer to
L<< Amazon's documentation for PUT|http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html >>.
=head2 delete_multiple_objects( $bucket, @keys )
B<Arguments>: a string with the bucket name, and an array with all the keys
to be deleted.
Amazon-S3
view release on metacpan or search on metacpan
lib/Amazon/S3.pm view on Meta::CPAN
return
if !$self->retry;
# In the field we are seeing issue of Amazon returning with a 400
# code in the case of timeout. From AWS S3 logs: REST.PUT.PART
# Backups/2017-05-04/<account>.tar.gz "PUT
# /Backups<path>?partNumber=27&uploadId=<id> - HTTP/1.1" 400
# RequestTimeout 360 20971520 20478 - "-" "libwww-perl/6.15"
my $http_codes_hr = $self->ua->codes_to_determinate();
$http_codes_hr->{$HTTP_BAD_REQUEST} = $TRUE;
lib/Amazon/S3.pm view on Meta::CPAN
return
if !$self->retry;
# In the field we are seeing issue with Amazon returning a 400
# code in the case of timeout. From AWS S3 logs: REST.PUT.PART
# Backups/2017-05-04/<account>.tar.gz "PUT
# /Backups<path>?partNumber=27&uploadId=<id> - HTTP/1.1" 400
# RequestTimeout 360 20971520 20478 - "-" "libwww-perl/6.15"
my $http_codes_hr = $self->ua->codes_to_determinate();
delete $http_codes_hr->{$HTTP_BAD_REQUEST};
lib/Amazon/S3.pm view on Meta::CPAN
: $EMPTY;
$headers->{'Content-Length'} = length $data;
my $retval = $self->_send_request_expect_nothing(
{ method => 'PUT',
path => "$bucket/",
headers => $headers,
data => $data,
region => $region,
},
lib/Amazon/S3.pm view on Meta::CPAN
return $FALSE;
}
# Send a HEAD request first, to find out if we'll be hit with a 307 redirect.
# Since currently LWP does not have true support for 100 Continue, it simply
# slams the PUT body into the socket without waiting for any possible redirect.
# Thus when we're reading from a filehandle, when LWP goes to reissue the request
# having followed the redirect, the filehandle's already been closed from the
# first time we used it. Thus, we need to probe first to find out what's going on,
# before we start sending any actual data.
########################################################################
lib/Amazon/S3.pm view on Meta::CPAN
You can create and list directory buckets.
I<Directory buckets use the S3 Express One Zone storage class, which
is recommended if your application is performance sensitive and
benefits from single-digit millisecond PUT and GET latencies.> -
L<https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html>
=over 10
=item list_directory_buckets
Amazon-S3Curl-PurePerl
view release on metacpan or search on metacpan
lib/Amazon/S3Curl/PurePerl.pm view on Meta::CPAN
#trailing slash for upload means curl will plop on the filename at the end, ruining the hash signature.
if ( $url =~ m|/$| ) {
my $file_name = ( File::Spec->splitpath( $self->local_file ) )[-1];
$url .= $file_name;
}
my $args = $self->_req('PUT',$url);
splice( @$args, $#$args, 0, "-T", $self->local_file );
return $args;
}
sub delete_cmd {
Amb
view release on metacpan or search on metacpan
cur_cv = cx->blk_sub.cv;
if (!cur_cv)
croak("Context has no CV!\n");
RETVAL = (SV*) newRV_inc( (SV*) cur_cv );
OUTPUT:
RETVAL
SV*
caller_op(context)
PERL_CONTEXT *cx = INT2PTR(PERL_CONTEXT*, SvIV(context));
OP *op = (OP*)cx->blk_oldcop;
SV *rv = newSV(0);
sv_setref_iv(rv, "B::COP", PTR2IV(op));
RETVAL = rv;
OUTPUT:
RETVAL
Amethyst
view release on metacpan or search on metacpan
Amethyst/Brain/Infobot/Module/Zippy.pm view on Meta::CPAN
Does someone from PEORIA have a SHORTER ATTENTION span than me? does your DRESSING ROOM have enough ASPARAGUS?
DON'T go!! I'm not HOWARD COSELL!! I know POLISH JOKES ... WAIT!!
Don't go!! I AM Howard Cosell! ... And I DON'T know Polish jokes!!
Don't hit me!! I'm in the Twilight Zone!!!
Don't SANFORIZE me!!
Don't worry, nobody really LISTENS to lectures in MOSCOW, either! ... FRENCH, HISTORY, ADVANCED CALCULUS, COMPUTER PROGRAMMING, BLACK STUDIES, SOCIOBIOLOGY! ... Are there any QUESTIONS??
Edwin Meese made me wear CORDOVANS!!
Eisenhower!! Your mimeograph machine upsets my stomach!!
Either CONFESS now or we go to "PEOPLE'S COURT"!!
Everybody gets free BORSCHT!
Everybody is going somewhere!! It's probably a garage sale or a disaster Movie!!
Amon2-Web-Dispatcher-RouterSimple-Extended
view release on metacpan or search on metacpan
lib/Amon2/Web/Dispatcher/RouterSimple/Extended.pm view on Meta::CPAN
our $VERSION = "0.05.01";
use Router::Simple 0.03;
my @METHODS = qw/GET POST PUT DELETE/;
my $submap;
sub import {
my $class = shift;
my %args = @_;
lib/Amon2/Web/Dispatcher/RouterSimple/Extended.pm view on Meta::CPAN
=item put $path, "${controller}#${action}"
this is equivalent to:
connect $path, { controller => $controller, action => $action }, { method => 'PUT' };
=item delete $path, "${controller}#${action}"
this is equivalent to:
Amon2
view release on metacpan or search on metacpan
lib/Amon2/Web/Dispatcher/RouterBoom.pm view on Meta::CPAN
if ($method eq 'get') {
$http_method = ['GET','HEAD'];
} elsif ($method eq 'post') {
$http_method = 'POST';
} elsif ($method eq 'put') {
$http_method = 'PUT';
} elsif ($method eq 'delete_') {
$http_method = 'DELETE';
}
$router->add($http_method, $path, \%dest);
lib/Amon2/Web/Dispatcher/RouterBoom.pm view on Meta::CPAN
Destination method pass is C<${class}#${method}> form.
The path declared with get() accepts GET and HEAD.
The path declared with post() accepts POST method.
The path declared with put() accepts PUT method.
The path declared with delete_() accepts DELETE method.
The path declared with any() accepts any methods.
=item C<< base($klass:Str) >>
Analizo
view release on metacpan or search on metacpan
lib/Analizo/Command/metrics.pm view on Meta::CPAN
exclude test code from the analysis. You could do that by passing something
like pass B<--exclude test>.
=back
=head1 OUTPUT FORMAT
The output is a stream of YAML documents. The first one presents metrics for
the project as a whole. The subsequent ones present per-module metrics, and thus
there will be as many of them as there are modules in your project.
Anansi-Database-MySQL
view release on metacpan or search on metacpan
lib/Anansi/Database/MySQL.pm view on Meta::CPAN
PASSWORD => 'somePassword',
USERNAME => 'someUser',
)) {
my $records = $OBJECT->statement(
undef,
INPUT => [
{
DEFAULT => '0',
NAME => 'yetAnotherField',
}
],
lib/Anansi/Database/MySQL.pm view on Meta::CPAN
USERNAME => 'someUser',
)) {
my $records = $OBJECT->channel(
'STATEMENT',
$component,
INPUT => [
{
DEFAULT => '0',
NAME => 'yetAnotherField',
}
],
lib/Anansi/Database/MySQL.pm view on Meta::CPAN
sub connect {
my ($self, $channel, %parameters) = @_;
return $self->SUPER::connect(
undef,
INPUT => [
{
INPUT => [
'dbi:mysql:database=', {
DEFAULT => 'mysql',
NAME => 'DATABASE',
REF => '',
},
lib/Anansi/Database/MySQL.pm view on Meta::CPAN
REF => '',
}, {
NAME => 'PASSWORD',
REF => '',
}, {
INPUT => [
{
DEFAULT => 0,
NAME => 'AutoCommit',
REF => '',
}, {
Anansi-Database-Oracle
view release on metacpan or search on metacpan
lib/Anansi/Database/Oracle.pm view on Meta::CPAN
PASSWORD => 'somePassword',
USERNAME => 'someUser',
)) {
my $records = $OBJECT->statement(
undef,
INPUT => [
{
DEFAULT => '0',
NAME => 'yetAnotherField',
}
],
lib/Anansi/Database/Oracle.pm view on Meta::CPAN
USERNAME => 'someUser',
)) {
my $records = $OBJECT->channel(
'STATEMENT',
$component,
INPUT => [
{
DEFAULT => '0',
NAME => 'yetAnotherField',
}
],
lib/Anansi/Database/Oracle.pm view on Meta::CPAN
sub connect {
my ($self, $channel, %parameters) = @_;
return $self->SUPER::connect(
undef,
INPUT => [
{
INPUT => [
'dbi:Oracle:host=', {
DEFAULT => '127.0.0.1',
NAME => 'HOST',
REF => '',
},
lib/Anansi/Database/Oracle.pm view on Meta::CPAN
REF => '',
}, {
NAME => 'PASSWORD',
REF => '',
}, {
INPUT => [
{
DEFAULT => 0,
NAME => 'AutoCommit',
REF => '',
}, {
Anansi-Database-PostgreSQL
view release on metacpan or search on metacpan
lib/Anansi/Database/PostgreSQL.pm view on Meta::CPAN
PASSWORD => 'somePassword',
USERNAME => 'someUser',
)) {
my $records = $OBJECT->statement(
undef,
INPUT => [
{
DEFAULT => '0',
NAME => 'yetAnotherField',
}
],
lib/Anansi/Database/PostgreSQL.pm view on Meta::CPAN
USERNAME => 'someUser',
)) {
my $records = $OBJECT->channel(
'STATEMENT',
$component,
INPUT => [
{
DEFAULT => '0',
NAME => 'yetAnotherField',
}
],
lib/Anansi/Database/PostgreSQL.pm view on Meta::CPAN
sub connect {
my ($self, $channel, %parameters) = @_;
return $self->SUPER::connect(
undef,
INPUT => [
{
INPUT => [
'dbi:Pg:dbname=', {
DEFAULT => $ENV{'PGDATABASE'} || '',
NAME => 'DATABASE',
REF => '',
},
lib/Anansi/Database/PostgreSQL.pm view on Meta::CPAN
}, {
DEFAULT => $ENV{'PGPASSWORD'} || undef,
NAME => 'PASSWORD',
REF => '',
}, {
INPUT => [
{
DEFAULT => 0,
NAME => 'AutoCommit',
REF => '',
}, {
Anansi-Database
view release on metacpan or search on metacpan
lib/Anansi/Database.pm view on Meta::CPAN
USERNAME => 'someUser',
)) {
my $records = $OBJECT->channel(
'STATEMENT',
$component,
INPUT => [
{
DEFAULT => '0',
NAME => 'yetAnotherField',
}
],
lib/Anansi/Database.pm view on Meta::CPAN
=head2 statement
my $result = Anansi::Database::statement(
$OBJECT,
undef,
INPUT => [
'hij' => 'someParameter',
'klm' => 'anotherParameter'
],
SQL => 'SELECT abc, def FROM some_table WHERE hij = ? AND klm = ?;',
STATEMENT => 'someStatement',
lib/Anansi/Database.pm view on Meta::CPAN
Named parameters.
=over 4
=item INPUT I<(Array, Optional)>
An array of hashes with each element corresponding to an equivalent B<?>
I<(Question mark)> found within the supplied B<SQL>. If the number of elements
is not the same as the number of B<?> I<(Question mark)>s found in the statement
then the statement is invalid. See the L<Anansi::DatabaseComponent::bind>
Anansi-DatabaseComponent
view release on metacpan or search on metacpan
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
sub connect {
my ($self, $channel, %parameters) = @_;
return $self->SUPER::connect(
undef,
INPUT => [
'some text',
{
NAME => 'someParameter',
}, {
INPUT => [
'more text',
{
NAME => 'anotherParameter',
},
'yet more text',
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
)) {
my $result = $database->statement(
undef,
$component,
SQL => 'SELECT someThing FROM someTable where modified = ?;',
INPUT => [
{
NAME => 'modified',
},
],
modified => '2011-02-22 00:21:46',
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
=head2 bind
if(Anansi::DatabaseComponent::bind($OBJECT,
HANDLE => $HANDLE,
INPUT => [
{
NAME => 'someParameter'
}, {
DEFAULT => 123,
NAME => 'anotherParameter'
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
}
));
if($OBJECT->bind(
HANDLE => $HANDLE,
INPUT => [
{
NAME => 'yetAnotherParameter',
TYPE => 'TEXT'
}
],
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
=item HANDLE I<(DBI::st, Required)>
The database statement handle.
=item INPUT I<(Array, Required)>
An array of hashes. Each element of the array corresponds to an equivalent B<?>
I<(Question mark)> within the prepared SQL statement. Each hash contains a
I<NAME> key with a value that represents a possible key within the I<VALUE>
parameter. Each hash may also contain a I<DEFAULT> key which contains the value
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
corresponding I<VALUE> parameter key exists and no I<DEFAULT> key has been
defined then an empty string is used for the value.
=item VALUE I<(Hash, Required)>
A hash of values to assign in the order specified by the I<INPUT> parameter.
=back
=back
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
sub bind {
my ($self, %parameters) = @_;
return 0 if(!defined($parameters{HANDLE}));
return 0 if(!defined($parameters{INPUT}));
return 0 if(ref($parameters{INPUT}) !~ /^ARRAY$/i);
return 0 if(!defined($parameters{VALUE}));
return 0 if(ref($parameters{VALUE}) !~ /^HASH$/i);
my $index = 1;
foreach my $input (@{$parameters{INPUT}}) {
if(defined(${$parameters{VALUE}}{${$input}{NAME}})) {
if(defined(${$input}{TYPE})) {
$parameters{HANDLE}->bind_param($index, ${$parameters{VALUE}}{${$input}{NAME}}, ${$input}{TYPE});
} else {
$parameters{HANDLE}->bind_param($index, ${$parameters{VALUE}}{${$input}{NAME}});
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
=back
Verifies that the supplied parameters are all hashes and that they each contain
a I<NAME> key with a string value. Returns B<1> I<(one)> when validity is
confirmed and B<0> I<(zero)> when an invalid structure is determined. Used to
validate the I<INPUT> parameter of the B<bind> method.
=cut
sub binding {
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
=head2 connect
if(1 == Anansi::DatabaseComponent::connect($OBJECT, undef
INPUT => [
'some text',
{
NAME => 'someParameter'
}, {
INPUT => [
'more text',
{
NAME => 'anotherParameter'
},
'yet more text'
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
someParameter => 12345,
anotherParameter => 'blah blah blah'
));
if(1 == Anansi::DatabaseComponent::channel($OBJECT, 'CONNECT',
INPUT => [
'blah blah blah',
{
DEFAULT => 123,
NAME => 'someParameter',
}
],
someParameter => 'some text'
));
if(1 == $OBJECT->connect(undef,
INPUT => [
{
INPUT => [
'some text',
{
NAME => 'someParameter'
},
'more text'
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
],
someParameter => 'in between'
));
if(1 == $OBJECT->channel('CONNECT',
INPUT => [
{
INPUT => [
{
NAME => 'abc'
}, {
NAME => 'def'
}
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
=over 4
=item HANDLE I<(DBI::db, Optional)>
The database handle of an existing database connection. Used in preference to
the I<INPUT> parameter.
=item INPUT I<(Array B<or> Scalar, Optional)>
An array or single value containing a description of each parameter in the order
that it is passed to the database driver's I<connect> method. Used when the
I<HANDLE> parameter does not exist.
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
=item DEFAULT I<(Optional)>
The value to use if no other value can be determined.
=item INPUT I<(Array B<or> Scalar, Optional)>
Contains a structure like that given in I<INPUT> above with the exception that
any further I<INPUT> keys will be ignored. As this key is only valid when
I<NAME> is undefined and I<REF> either specifies a string or a hash, it's value
will be either a concatenation of all the calculated strings or a hash
containing all of the specified keys and values.
=item NAME I<(String, Optional)>
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
$self->disconnect();
if(defined($parameters{HANDLE})) {
return 0 if(ref($parameters{HANDLE}) !~ /^DBI::db$/);
$self->{HANDLE} = $parameters{HANDLE};
$self->{MANAGE_HANDLE} = 0;
} elsif(!defined($parameters{INPUT})) {
return 0;
} elsif(ref($parameters{INPUT}) !~ /^ARRAY$/i) {
return 0;
} else {
my @inputs;
foreach my $input (@{$parameters{INPUT}}) {
if(ref($input) !~ /^HASH$/i) {
push(@inputs, $input);
next;
}
my $value = undef;
$value = ${$input}{DEFAULT} if(defined(${$input}{DEFAULT}));
if(!defined(${$input}{NAME})) {
if(!defined(${$input}{INPUT})) {
} elsif(ref(${$input}{INPUT}) !~ /^ARRAY$/i) {
} elsif(!defined(${$input}{REF})) {
} elsif(ref(${$input}{REF}) !~ /^$/i) {
} elsif('' eq ${$input}{REF}) {
my @subInputs;
for(my $index = 0; $index < scalar(@{${$input}{INPUT}}); $index++) {
if(ref(${${$input}{INPUT}}[$index]) =~ /^$/i) {
push(@subInputs, ${${$input}{INPUT}}[$index]);
next;
} elsif(ref(${${$input}{INPUT}}[$index]) !~ /^HASH$/) {
next;
}
my $subValue = '';
$subValue = ${${${$input}{INPUT}}[$index]}{DEFAULT} if(defined(${${${$input}{INPUT}}[$index]}{DEFAULT}));
if(!defined(${${${$input}{INPUT}}[$index]}{NAME})) {
} elsif(ref(${${${$input}{INPUT}}[$index]}{NAME}) !~ /^$/) {
} elsif(defined($parameters{${${${$input}{INPUT}}[$index]}{NAME}})) {
if(!defined(${${${$input}{INPUT}}[$index]}{REF})) {
$subValue = $parameters{${${${$input}{INPUT}}[$index]}{NAME}} if('' eq ref($parameters{${${${$input}{INPUT}}[$index]}{NAME}}));
} elsif(ref(${${${$input}{INPUT}}[$index]}{REF}) !~ /^$/) {
} elsif('' ne ${${${$input}{INPUT}}[$index]}{REF}) {
} elsif('' ne ref($parameters{${${${$input}{INPUT}}[$index]}{NAME}})) {
} else {
$subValue = $parameters{${${${$input}{INPUT}}[$index]}{NAME}};
}
}
push(@subInputs, $subValue);
}
$value = join('', @subInputs);
} elsif(${$input}{REF} =~ /^HASH$/i) {
my %subInputs;
foreach my $subInput (@{${$input}{INPUT}}) {
next if(ref($subInput) !~ /^HASH$/i);
my $subValue = undef;
$subValue = ${$subInput}{DEFAULT} if(defined(${$subInput}{DEFAULT}));
if(!defined(${$subInput}{NAME})) {
} elsif(ref(${$subInput}{NAME}) !~ /^$/) {
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
my %refs = map { $_ => 1 } (@{${$input}{REF}});
if(!defined($refs{ref($parameters{${$input}{NAME}})})) {
} elsif(ref($parameters{${$input}{NAME}}) !~ /^HASH$/i) {
$value = $parameters{${$input}{NAME}};
} else {
if(!defined(${$input}{INPUT})) {
$value = $parameters{${$input}{NAME}};
} elsif(ref(${$input}{INPUT}) !~ /^HASH$/i) {
$value = $parameters{${$input}{NAME}};
} else {
my %subInputs;
foreach my $subInput (keys(%{${$input}{INPUT}})) {
if(ref($subInput) !~ /^HASH$/i) {
$subInputs{$subInput} = $subInput;
next;
}
my $subValue = undef;
$value = ${${${$input}{INPUT}}{$subInput}}{DEFAULT} if(defined(${${${$input}{INPUT}}{$subInput}}{DEFAULT}));
if(!defined(${${${$input}{INPUT}}{$subInput}}{NAME})) {
} elsif(ref(${${${$input}{INPUT}}{$subInput}}{NAME}) !~ /^$/) {
} elsif(defined($parameters{${${${$input}{INPUT}}{$subInput}}{NAME}})) {
if(!defined(${${${$input}{INPUT}}{$subInput}}{REF})) {
} elsif(ref(${${${$input}{INPUT}}{$subInput}}{REF}) =~ /^ARRAY$/i) {
my %refs = map { $_ => 1 } (@{${${${$input}{INPUT}}{$subInput}}{REF}});
$subValue = $parameters{${${${$input}{INPUT}}{$subInput}}{NAME}} if(defined($refs{ref($parameters{${${${$input}{INPUT}}{$subInput}}{NAME}})}));
} elsif(ref(${${${$input}{INPUT}}{$subInput}}{REF}) !~ /^$/) {
} elsif(${${${$input}{INPUT}}{$subInput}}{REF} ne ref($parameters{${${${$input}{INPUT}}{$subInput}}{NAME}})) {
} else {
$subValue = $parameters{${${${$input}{INPUT}}{$subInput}}{NAME}};
}
}
$subInputs{$subInput} = $subValue;
}
$value = \%subInputs;
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
} elsif(ref(${$input}{REF}) !~ /^$/) {
} elsif(${$input}{REF} ne ref($parameters{${$input}{NAME}})) {
} elsif(ref($parameters{${$input}{NAME}}) !~ /^HASH$/i) {
$value = $parameters{${$input}{NAME}};
} else {
if(!defined(${$input}{INPUT})) {
$value = $parameters{${$input}{NAME}};
} elsif(ref(${$input}{INPUT}) !~ /^HASH$/i) {
$value = $parameters{${$input}{NAME}};
} else {
my %subInputs;
foreach my $key (keys(%{${$input}{INPUT}})) {
if(ref($subInput) !~ /^HASH$/i) {
push(@subInputs, $subInput);
next;
}
my $subValue = undef;
$value = ${${${$input}{INPUT}}{$subInput}}{DEFAULT} if(defined(${${${$input}{INPUT}}{$subInput}}{DEFAULT}));
if(!defined(${${${$input}{INPUT}}{$subInput}}{NAME})) {
} elsif(ref(${${${$input}{INPUT}}{$subInput}}{NAME}) !~ /^$/) {
} elsif(defined($parameters{${${${$input}{INPUT}}{$subInput}}{NAME}})) {
if(!defined(${${${$input}{INPUT}}{$subInput}}{REF})) {
} elsif(ref(${${${$input}{INPUT}}{$subInput}}{REF}) =~ /^ARRAY$/i) {
my %refs = map { $_ => 1 } (@{${${${$input}{INPUT}}{$subInput}}{REF}});
$subValue = $parameters{${${${$input}{INPUT}}{$subInput}}{NAME}} if(defined($refs{ref($parameters{${${${$input}{INPUT}}{$subInput}}{NAME}})}));
} elsif(ref(${${${$input}{INPUT}}{$subInput}}{REF}) !~ /^$/) {
} elsif(${${${$input}{INPUT}}{$subInput}}{REF} ne ref($parameters{${${${$input}{INPUT}}{$subInput}}{NAME}})) {
} else {
$subValue = $parameters{${${${$input}{INPUT}}{$subInput}}{NAME}};
}
}
$subInputs{$subInput} = $subValue;
}
$value = \%subInputs;
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
STATEMENT => 'an associated name'
);
if(defined($PREPARATION));
if(1 == Anansi::DatabaseComponent::channel($OBJECT, 'PREPARE',
INPUT => [
{
NAME => 'someParameter'
}
],
SQL => 'SELECT abc, def FROM some_table WHERE ghi = ?',
STATEMENT => 'another associated name'
));
if(1 == $OBJECT->prepare(undef,
INPUT => [
{
NAME => 'abc'
}, {
NAME => 'def'
}, {
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
SQL => 'INSERT INTO some_table (abc, def, ghi) VALUES (?, ?, ?);',
STATEMENT => 'yet another name'
));
if(1 == $OBJECT->channel('PREPARE',
INPUT => [
{
NAME => ''
}
],
SQL => '',
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
Named parameters.
=over 4
=item INPUT I<Array, Optional>
An array of hashes. Each hash should contain a I<NAME> key with a string value
that represents the name of a parameter to associate with the corresponding B<?>
I<(Question mark)>. See the I<bind> method for details.
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
return 0 if(ref($parameters{SQL}) !~ /^$/);
$parameters{SQL} =~ s/^\s*(.*)|(.*)\s*$/$1/g;
my $questionMarks = $parameters{SQL};
my $questionMarks = $questionMarks =~ s/\?/$1/sg;
if(0 == $questionMarks) {
return 0 if(defined($parameters{INPUT}));
} elsif(!defined($parameters{INPUT})) {
return 0;
} elsif(ref($parameters{INPUT}) !~ /^ARRAY$/i) {
return 0;
} elsif(scalar(@{$parameters{INPUT}}) != $questionMarks) {
return 0;
} else {
return 0 if(!$self->binding((@{$parameters{INPUT}})));
}
my $handle;
eval {
$handle = $self->{HANDLE}->prepare($parameters{SQL});
1;
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
};
my %statement = (
HANDLE => $handle,
SQL => $parameters{SQL},
);
$statement{INPUT} = $parameters{INPUT} if(defined($parameters{INPUT}));
${$self->{STATEMENTS}}{$parameters{STATEMENT}} = \%statement;
}
return 1 if(defined($channel));
return ${$self->{STATEMENTS}}{$parameters{STATEMENT}};
}
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
Describes whether to perform the subsequent sequence statement.
=back
=item INPUT I<(Array B<or> String, Optional)>
An array of strings or a string containing the variables or variable data. Only
used when I<COMMAND> contains B<"LOOP">, B<"RUN"> or B<"SQL">.
=item NAME I<(String, Optional)
A sequence name associated with the SQL statement, control structure or external
process trigger. When I<COMMAND> is B<"LOOP">, represents the name of a script
variable hash that will contain the current I<ITERATION> of the loop starting at
B<0> I<(zero)>, how many I<ITERATIONS> the loop is expected to perform a B<1>
I<(one)> or greater or a B<0> I<(zero)> for indeterminate and the I<INPUT> value
to use in the iteration or B<undef> if indeterminate. When I<COMMAND> is B<"RUN">
, represents the name of a script variable that will contain the results of the
trigger. When I<COMMAND> is B<"TEST">, represents the name of a script variable
that will either contain the result of the current test or the name of a script
variable that should be used to determine whether the sequence statement should
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
=head2 statement
my $result = Anansi::DatabaseComponent::statement($OBJECT, undef,
INPUT => [
'hij' => 'someParameter',
'klm' => 'anotherParameter'
],
SQL => 'SELECT abc, def FROM some_table WHERE hij = ? AND klm = ?;',
STATEMENT => 'someStatement',
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
Named parameters.
=over 4
=item INPUT I<(Array, Optional)>
An array of hashes with each element corresponding to an equivalent B<?>
I<(Question mark)> found within the supplied I<SQL>. If the number of elements
is not the same as the number of B<?> I<(Question mark)>s found in the statement
then the statement is invalid. See the I<bind> method for details.
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
return 0 if(ref($self) =~ /^(|ARRAY|CODE|FORMAT|GLOB|HASH|IO|LVALUE|REF|Regexp|SCALAR|VSTRING)$/i);
my $prepared = $self->prepare(undef, (%parameters));
my $handle;
if($prepared) {
$handle = ${$prepared}{HANDLE};
if(defined(${$prepared}{INPUT})) {
my $bound = $self->bind(
HANDLE => $handle,
INPUT => ${$prepared}{INPUT},
VALUE => \%parameters,
);
return 0 if(!$bound);
}
} else {
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
return 0;
};
my $questionMarks = $parameters{SQL};
my $questionMarks = $questionMarks =~ s/\?/$1/sg;
if(0 == $questionMarks) {
if(defined($parameters{INPUT})) {
$self->rollback();
return 0;
}
} elsif(!defined($parameters{INPUT})) {
$self->rollback();
return 0;
} elsif(ref($parameters{INPUT}) !~ /^ARRAY$/i) {
$self->rollback();
return 0;
} elsif(scalar(@{$parameters{INPUT}}) != $questionMarks) {
$self->rollback();
return 0;
} else {
if(!$self->bind(
HANDLE => $handle,
INPUT => $parameters{INPUT},
VALUE => \%parameters,
)) {
$self->rollback();
return 0;
}
Anarres-Mud-Driver
view release on metacpan or search on metacpan
Compiler/Compiler.xs view on Meta::CPAN
Anarres::Mud::Driver::Compiler
new(class)
SV * class
CODE:
RETVAL = Newz(0, RETVAL, 1, struct _amd_parser);
OUTPUT:
RETVAL
int
lex(class, str)
SV * class
char * str
CODE:
test_lexer(str);
RETVAL = 0;
OUTPUT:
RETVAL
int
parse(class, prog, str)
SV * class
SV * prog
char * str
CODE:
amd_yyparser_parse(prog, str);
RETVAL = 0;
OUTPUT:
RETVAL
void
DESTROY(self)
Anarres::Mud::Driver::Compiler self
Ancient
view release on metacpan or search on metacpan
t/1018-trim-maybe.t view on Meta::CPAN
# trim + maybe combo use case
my $input = " user input ";
my $cleaned = trim($input);
is($cleaned, "user input", 'trim user input');
is(maybe($cleaned, uc($cleaned)), "USER INPUT", 'maybe transform cleaned input');
done_testing;
Android-ElectricSheep-Automator
view release on metacpan or search on metacpan
script/electric-sheep-pull-app-apk.pl view on Meta::CPAN
}
print STDOUT "$0 : done, success! Extracted ${Napks} APK(s) from ${Npackages} packages, written to output dir '$OUTDIR'.\n";
sub usage {
return "Usage $0 --package NAME --output apkdir --configfile CONFIGFILE [--wildcard] [--device DEVICE] [--verbosity v]\n"
. "\nThis script will pull the APK(s) of the specified package NAME into the local dir 'OUTPUT'. The package NAME can be the full package name, e.g. 'com.android.gallery2' or a part of it, e.g. 'gallery'. Use --wildcard option if you want to match ...
. "\nExample:\n"
. " match all packages with 'gallery2' in their name:\n"
. "$0 --configfile config/myapp.conf --output apkdir --package 'calendar2' --wildcard\n"
. "\n match the package name 'com.android.gallery2' exactly:\n"
. "$0 --configfile config/myapp.conf --output apkdir --package 'com.android.gallery2'\n"
AnnoCPAN
view release on metacpan or search on metacpan
lib/AnnoCPAN/PodToHtml.pm view on Meta::CPAN
}
sub textblock {
my ($self, $text, $line_num, $pod_para) = @_;
return '' if $self->{annocpan_begin_depth};
my $out_fh = $self->{_OUTPUT};
my $p = $self->interpolate($text, $line_num);
for ($p) {
s/(?<!\0)&/&/g;
s/(?<!\0)</</g;
s/(?<!\0)>/>/g;
AntTweakBar
view release on metacpan or search on metacpan
lib/AntTweakBar.xs view on Meta::CPAN
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(*(int*)value)));
PUTBACK;
call_sv(*cb, G_DISCARD);
FREETMPS;
LEAVE;
}
lib/AntTweakBar.xs view on Meta::CPAN
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVnv(*(double*)value)));
PUTBACK;
call_sv(*cb, G_DISCARD);
FREETMPS;
LEAVE;
}
lib/AntTweakBar.xs view on Meta::CPAN
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpv(*(char**)value, 0)));
PUTBACK;
call_sv(*cb, G_DISCARD);
FREETMPS;
LEAVE;
}
lib/AntTweakBar.xs view on Meta::CPAN
av_push(av, newSVnv(values[i])); \
} \
\
PUSHMARK(SP); \
XPUSHs(sv_2mortal(newRV_inc((SV*)av))); \
PUTBACK; \
\
call_sv(*cb, G_DISCARD); \
\
FREETMPS; \
LEAVE; \
Any-Renderer-Data-Printer
view release on metacpan or search on metacpan
t/01-check_output.t view on Meta::CPAN
use warnings;
use Test::More tests => 3;
use Any::Renderer;
use constant OUTPUT_DEFAULT => q[\ {
bar [
[0] "foo1",
[1] "foo2",
[2] "foo3"
],
foo "bar"
}];
use constant OUTPUT_INDENT_10 => q[\ {
bar [
[0] "foo1",
[1] "foo2",
[2] "foo3"
],
t/01-check_output.t view on Meta::CPAN
foo => 'bar',
bar => ['foo1','foo2','foo3']
};
ok($r->render($hash) eq OUTPUT_DEFAULT, 'Output - Default');
ok( $r2->render($hash) eq OUTPUT_INDENT_10, 'Output - Indent 10');
Any-Template
view release on metacpan or search on metacpan
lib/Any/Template/Backend/Text/Template.pm view on Meta::CPAN
return 1;
}
sub process_to_filehandle {
my ($self, $data, $fh) = @_;
$self->{engine}->fill_in(HASH => $data, OUTPUT => $fh);
return 1;
}
#
# This marshalls the Any::Template ctor options into the form required for Text::Template
AnyEvent-Campfire-Client
view release on metacpan or search on metacpan
lib/AnyEvent/Campfire/Client.pm view on Meta::CPAN
$self->uri->query_form(''); # clear query
}
sub get { shift->request( 'GET', @_ ) }
sub post { shift->request( 'POST', @_ ) }
sub put { shift->request( 'PUT', @_ ) }
sub delete { shift->request( 'DELETE', @_ ) }
__PACKAGE__->meta->make_immutable;
1;
AnyEvent
view release on metacpan or search on metacpan
lib/AnyEvent/Impl/Irssi.pm view on Meta::CPAN
my $fd = fileno $arg{fh};
defined $fd or $fd = $arg{fh};
my $source = Irssi::input_add
$fd,
$arg{poll} eq "r" ? Irssi::INPUT_READ : Irssi::INPUT_WRITE,
$cb,
undef;
bless \\$source, "AnyEvent::Impl::Irssi::io"
}
( run in 0.921 second using v1.01-cache-2.11-cpan-39bf76dae61 )