Result:
found more than 539 distributions - search limited to the first 2001 files matching your query ( run in 5.027 )


Acme-CPANModulesBundle-Import-MojoliciousAdvent-2018

 view release on metacpan or  search on metacpan

devdata/https_mojolicious.io_blog_2018_12_07_openapi_  view on Meta::CPAN

<h4>Defining an Endpoint</h4>

<p>Each of the paths available to the API are defined within the paths object.</p>

<pre><code>paths:
  # The path to the endpoint
  /search/web:
    # The HTTP method that the endpoint accepts
    get:
      # A unique identifier for the method
      operationId: search_web
      # This attribute points to the name of the class in the appliction
      # and the method to call separated by `#`

devdata/https_mojolicious.io_blog_2018_12_07_openapi_  view on Meta::CPAN

    - &quot;null&quot;
</code></pre>

<h3>The MetaCPAN Specification</h3>

<p>The entire specification doesn’t need to be complete in order to get OpenAPI up and running. When documenting an existing API, it’s possible to with one portion of the API. With MetaCPAN we started with the search endpoints.</p>

<p>The <a href="https://github.com/metacpan/metacpan-api/blob/master/root/static/v1.yml">spec file can be viewed here</a> and the <a href="https://fastapi.metacpan.org/static/index.html">API documentation here</a></p>

<h2>Further Reading</h2>

 view all matches for this distribution


Acme-CPANModulesBundle-Import-PerlDancerAdvent-2018

 view release on metacpan or  search on metacpan

devdata/http_advent.perldancer.org_2018_20  view on Meta::CPAN

<pre class="prettyprint">use Test::More;
use Test::Mojo;
my $t = Test::Mojo-&gt;with_roles('+PSGI')-&gt;new('app.psgi');</pre>

<p>With that out of the way, on to the tests!
In our first tests we'll focus on the plain text endpoint <code>/text</code>.</p>
<pre class="prettyprint">$t-&gt;get_ok('/text')
  -&gt;status_is(200)
  -&gt;content_type_like(qr[text/plain])
  -&gt;content_is('hello world');</pre>

devdata/http_advent.perldancer.org_2018_20  view on Meta::CPAN

<pre class="prettyprint">$t-&gt;get_ok('/text', form =&gt; { name =&gt; 'santa' })
  -&gt;status_is(200)
  -&gt;content_type_like(qr[text/plain])
  -&gt;content_is('hello santa');</pre>

<p>Moving on we request the data endpoint, both without and with a query, then similarly test the responses.</p>
<pre class="prettyprint">$t-&gt;get_ok('/data')
  -&gt;status_is(200)
  -&gt;content_type_like(qr[application/json])
  -&gt;json_is('/hello' =&gt; 'world');

devdata/http_advent.perldancer.org_2018_20  view on Meta::CPAN

  -&gt;json_is('/hello' =&gt; 'rudolph');</pre>

<p>You can see we use the <code>json_is</code> method to test the responses.
Now, the test could have been <code>-&gt;json_is({hello =&gt; 'rudolph'})</code> if had wanted to test the entire document.
By passing a <a href="https://mojolicious.org/perldoc/Mojo/JSON/Pointer">JSON Pointer</a> I can inspect only the portions I'm interested in.</p>
<p>Finally I'm going to test the HTML endpoint.
As I said above, the result resists easy parsing.
We want to test the <code>dd</code> tag contents that follows a <code>dt</code> tag with the id <code>hello</code>, all inside a <code>dl</code> tag with the id <code>data</code>.
That would be a monstrous regexp (hehe).
However it is a piece of cake using <a href="https://mojolicious.org/perldoc/Mojo/DOM/CSS">CSS Selectors</a>.</p>
<pre class="prettyprint">$t-&gt;get_ok('/html')

 view all matches for this distribution


Acme-Globus

 view release on metacpan or  search on metacpan

lib/Acme/Globus.pm  view on Meta::CPAN

be ill-advised if not impossible.

=head1 SYNOPSIS

    my $g = Globus->new($username,$path_to_ssh_key) ;
    $g->endpoint_add_shared( 'institution#endpoint', $directory, $endpoint_name ) ;
    $g->acl_add( $endpoint . '/', 'djacoby@example.com' ) ;
    
=head1 METHODS

=head2 BASICS

lib/Acme/Globus.pm  view on Meta::CPAN


=head3 B<scp>

=head3 B<transfer>

Both commands take a source, or from path (including endpoint),
a destination, or to path (includint endpoint), and a boolean indicating
whether you're copying recursively or not.

=cut 

sub delete { }

lib/Acme/Globus.pm  view on Meta::CPAN


acl-* is the way that Globus refers to permissions

By the interface, Globus supports adding shares by email address, 
by Globus username or by Globus group name. This module sticks to
using email address. acl_add() takes an endpoint, an email address 
you're sharing to, and a boolean indicating whether this share is
read-only or read-write. acl_add() returns a share id.

acl_remove() uses that share id to identify which shares are to be 
removed.

acl_list() returns an array of hashes containing the information about 
each user with access to an endpoint, including the share ID and permissions.

=cut

sub identity_details {
    my ( $self, $identity_id ) = @_ ;

lib/Acme/Globus.pm  view on Meta::CPAN

    my $obj = decode_json $result ;
    return wantarray ? %$obj : $obj ;
    }

sub acl_add {
    my ( $self, $endpoint, $email, $rw ) = @_ ;
    my $readwrite = 'rw' ;
    $readwrite = 'r' unless $rw ;
    my $command
        = qq{acl-add $endpoint --identityusername=${email} --perm $readwrite }
        ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    my ($id) = reverse grep {m{\w}} split m{\s}, $result ;
    return $id ;
    }

sub acl_list {
    my ( $self, $endpoint ) = @_ ;
    my $command = qq{acl-list $endpoint} ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    my $slist = decode_json $result ;
    my @list = grep { $_->{permissions} ne 'rw' } @$slist ;
    return wantarray ? @list : \@list ;
    }

sub acl_remove {
    my ( $self, $endpoint_uuid, $share_uuid ) = @_ ;
    my $command = qq{acl-remove $endpoint_uuid --id $share_uuid} ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    return $result ;
    }

=head3 B<endpoint_add_shared>

=head3 B<endpoint_list>

=head3 B<endpoint_search>

=head3 B<endpoint_remove>

endpoint_add_shared() handles the specific case of creating an endpoint 
from an existing endpoint, not the general case.  It takes the endpoint
where you're sharing from, the path you're sharing, and the endpoint 
you're creating. If you are user 'user' and creating the endpoint 'test',
the command takes 'test', not 'user#test'.

endpoint_remove and endpoint_list, however, take a full endpoint name, like 'user#test'.

Current usage is endpoint_list for a list of all our shares, and endpoint_search
for details of each individual share

=head3 B<list_my_endpoints>

=head3 B<search_my_endpoints>

list_my_endpoints() and search_my_endpoints() were added once I discovered
the failings of existing list and search. These tools return a hashref
of hashrefs holding the owner, host_endpoint, host_endpoint_name,
credential_status, and most importantly, the id, legacy_name and display_name.

For older shares, legacy_name will be something like 'purduegcore#hr00001_firstshare'
and display_name will be 'n/a', while for newer shares, legacy_name will be
'purduegcore#SAME_AS_ID' and display_name will be like older shares' legacy_name,
'purduegcore#hr99999_filled_the_space'. In both cases, the value you want
to use to get details or to remove a share is the id, which is a UUID. 

=cut

sub endpoint_add_shared {
    my ( $self, $sharer_endpoint, $path, $endpoint ) = @_ ;

    # my $command
    #     = qq{endpoint-add --sharing "$sharer_endpoint$path" $endpoint } ;
    # my $command
    #     = qq{endpoint-add -n $endpoint --sharing "$sharer_endpoint$path" } ;
    my $command = join ' ',
        q{endpoint-add},
        q{--sharing}, "$sharer_endpoint$path",
        q{-n},        $endpoint,
        ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    return $result ;
    }

# sub endpoint_list {
#     my ( $self, $endpoint ) = @_ ;
#     my $command ;
#     if ($endpoint) {
#         $command = qq{endpoint-list $endpoint } ;
#         }
#     else {
#         $command = qq{endpoint-list} ;
#         }
#     my $result
#         = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
#     my @result = map { ( split m{\s}, $_ )[0] } split "\n", $result ;
#     return wantarray ? @result : \@result ;
#     }

#lists all my endpoint
sub endpoint_list {
    my ($self) = @_ ;
    my $command = 'endpoint-search --scope=my-endpoints' ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    my @result = map { s{\s}{}g ; $_ }
        map   { ( reverse split m{:} )[0] }
        grep  {m{Legacy}}
        split m{\n}, $result ;
    return wantarray ? @result : \@result ;
    }

sub endpoint_search {
    my ( $self, $search ) = @_ ;
    return {} unless $search ;
    my $command = qq{endpoint-search $search --scope=my-endpoints} ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    my %result = map {
        chomp ;
        my ( $k, $v ) = split m{\s*:\s}, $_ ;

lib/Acme/Globus.pm  view on Meta::CPAN

        }
        split m{\n}, $result ;
    return wantarray ? %result : \%result ;
    }

sub list_my_endpoints {
    my ($self) = @_ ;
    my $command = 'endpoint-search --scope=my-endpoints' ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    my %result = map {
        my $hash ;
        %$hash = map {

lib/Acme/Globus.pm  view on Meta::CPAN

        }
        split m{\n\n}, $result ;
    return wantarray ? %result : \%result ;
    }

sub search_my_endpoints {
    my ( $self, $search ) = @_ ;
    my %result ;
    my $command = qq{endpoint-search $search --scope=my-endpoints} ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    %result = map {
        my $hash ;
        %$hash = map {

lib/Acme/Globus.pm  view on Meta::CPAN

        }
        split m{\n\n}, $result ;
    return wantarray ? %result : \%result ;
    }

sub endpoint_remove {
    my ( $self, $endpoint ) = @_ ;
    my $command = qq{endpoint-remove $endpoint} ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;
    return $result ;
    }

# Sucks. Use endpoint_search instead
sub endpoint_details {
    my ( $self, $endpoint ) = @_ ;
    my $command = qq{endpoint-details $endpoint} ;
    my $result
        = _globus_action( $command, $self->{username}, $self->{key_path} ) ;

    my %result = map {
        chomp ;

lib/Acme/Globus.pm  view on Meta::CPAN

        } split m{\n}, $result ;

    return wantarray ? %result : \%result ;
    }

=head3 B<endpoint_activate>

=head3 B<endpoint_add>

=head3 B<endpoint_deactivate>

=head3 B<endpoint_modify>

=head3 B<endpoint_rename>

Stubs

=cut

sub endpoint_activate   { }
sub endpoint_add        { }
sub endpoint_deactivate { }
sub endpoint_modify     { }
sub endpoint_rename     { }

=head2 OTHER

=head3 B<help>   

 view all matches for this distribution


Acme-Insult-Glax

 view release on metacpan or  search on metacpan

lib/Acme/Insult/Glax.pm  view on Meta::CPAN

    our %EXPORT_TAGS = ( all => [ our @EXPORT_OK = qw[insult adjective] ] );
    #
    use overload '""' => sub ( $s, $u, $b ) { $s->{insult} // () };
    my $api = URI->new('https://insult.mattbas.org/api/');
    #
    sub _http ( $endpoint, %params ) {
        state $http
            //= HTTP::Tiny->new( default_headers => { Accept => 'application/json' }, agent => sprintf '%s/%.2f ', __PACKAGE__, our $VERSION );
        ( my $hey = $api->clone )->path( '/api/' . $endpoint . '.json' );
        $hey->query_form(%params);
        my $res = $http->get( $hey->as_string );    # {success} is true even when advice is not found but we'll at least know when we have valid JSON
        $res->{success} ? decode_json( $res->{content} ) : ();
    }
    #

 view all matches for this distribution


Acme-MetaSyntactic-Themes

 view release on metacpan or  search on metacpan

lib/Acme/MetaSyntactic/services.pm  view on Meta::CPAN

neteh_ext
netgw
netinfo
netinfo_local
netiq
netiq_endpoint
netiq_endpt
netiq_mc
netiq_ncap
netiq_qcheck
netiq_voipa

 view all matches for this distribution


Acme-Parataxis

 view release on metacpan or  search on metacpan

eg/fork_offload.pl  view on Meta::CPAN

        };
    }
);

# The concurrency cap, reconstructed from the windows each child reported. Walk
# the start/stop endpoints and take the deepest overlap; with $POOL children
# allowed it must never exceed $POOL, and it must exceed zero or the closures
# did not really overlap at all.
my $high = 0;
{
    my @events = map { ( [ $_->{start}, +1 ], [ $_->{end}, -1 ] ) } @{ $rv->{out} };

 view all matches for this distribution


AgentPushKit-Client

 view release on metacpan or  search on metacpan

lib/AgentPushKit/Client/ApiClient.pm  view on Meta::CPAN

    }
    $self->{http_timeout} = $seconds;
}

# make the HTTP request
# @param string $resourcePath path to method endpoint
# @param string $method method to call
# @param array $queryParams parameters to be place in query URL
# @param array $postData parameters to be placed in POST body
# @param array $headerParams parameters to be place in request header
# @return mixed

lib/AgentPushKit/Client/ApiClient.pm  view on Meta::CPAN

    my ($self, $header_params, $query_params, $auth_settings) = @_;

    return $self->_global_auth_setup($header_params, $query_params)
        unless $auth_settings && @$auth_settings;

    # one endpoint can have more than 1 auth settings
    foreach my $auth (@$auth_settings) {
        # determine which one to use
        if (!defined($auth)) {
            # TODO show warning about auth setting not defined
        }
        elsif ($auth eq 'UserOrAgent') {
            # this endpoint requires Bearer (Agent Push Kit JWT or apt_ token) authentication (access token)
            if ($self->{config}{access_token}) {
                $header_params->{'Authorization'} = 'Bearer ' . $self->{config}{access_token};
            }
        }
        elsif ($auth eq 'AgentToken') {
            # this endpoint requires Bearer (apt_) authentication (access token)
            if ($self->{config}{access_token}) {
                $header_params->{'Authorization'} = 'Bearer ' . $self->{config}{access_token};
            }
        }
        elsif ($auth eq 'OrganizationApiKey') {
            # this endpoint requires Bearer (apk_) authentication (access token)
            if ($self->{config}{access_token}) {
                $header_params->{'Authorization'} = 'Bearer ' . $self->{config}{access_token};
            }
        }
        else {
           # TODO show warning about security definition not found
        }
    }
}

# The endpoint API class has not found any settings for auth. This may be deliberate,
# in which case update_params_for_auth() will be a no-op. But it may also be that the
# OpenAPI Spec does not describe the intended authorization. So we check in the config for any
# auth tokens and if we find any, we use them for all endpoints;
sub _global_auth_setup {
    my ($self, $header_params, $query_params) = @_;

    my $tokens = $self->{config}->get_tokens;
    return unless keys %$tokens;

 view all matches for this distribution


Airlock

 view release on metacpan or  search on metacpan

examples/login.pl  view on Meta::CPAN

# The device side: get a token from one of the example apps.
#
#   perl -Ilib examples/login.pl [scope ...]
#
# Against an OpenID Connect provider, pass issuer => 'https://.../realms/x'
# instead of the two endpoints and let the client discover them.

use strict;
use warnings;
use Airlock::Client;

my $base   = $ENV{AIRLOCK_EXAMPLE_URL} // 'http://localhost:5000';
my $client = Airlock::Client->new(
  client_id       => 'demo-cli',
  scope           => join( ' ', @ARGV ),
  device_endpoint => $base.'/airlock/device',
  token_endpoint  => $base.'/airlock/token'
);

my $token = $client->login;

print 'access_token: '.$token->{access_token}."\n";

 view all matches for this distribution


Akamai-PropertyFetcher

 view release on metacpan or  search on metacpan

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN


    # 基本URL
    my $baseurl = "https://" . $agent->{host};

# Endpoint to retrieve contract IDs
my $contracts_endpoint = "$baseurl/papi/v1/contracts";
my $contracts_resp = $agent->get($contracts_endpoint);
die "Error retrieving contract ID: " . $contracts_resp->status_line unless $contracts_resp->is_success;
my $contracts_data = decode_json($contracts_resp->decoded_content);
my @contract_ids = map { $_->{contractId} } @{ $contracts_data->{contracts}->{items} };

# Endpoint to retrieve group IDs
my $groups_endpoint = "$baseurl/papi/v1/groups";
my $groups_resp = $agent->get($groups_endpoint);
die "Error retrieving group ID: " . $groups_resp->status_line unless $groups_resp->is_success;
my $groups_data = decode_json($groups_resp->decoded_content);
my @group_ids = map { $_->{groupId} } @{ $groups_data->{groups}->{items} };

# Process all combinations of contract IDs and group IDs
foreach my $contract_id (@contract_ids) {
    foreach my $group_id (@group_ids) {
        my $properties_endpoint = "$baseurl/papi/v1/properties?contractId=$contract_id&groupId=$group_id";
        my $properties_resp = $agent->get($properties_endpoint);

        if ($properties_resp->is_success) {
            # Retrieve property information
            my $properties_data = decode_json($properties_resp->decoded_content);
            my $properties = $properties_data->{properties}->{items};

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

                my $base_dir = "property";
                my $property_dir = File::Spec->catdir($base_dir, $property_name);
                make_path($property_dir) unless -d $property_dir;

                # Retrieve activated version information
                my $activations_endpoint = "$baseurl/papi/v1/properties/$property_id/activations?contractId=$contract_id&groupId=$group_id";
                my $activations_resp = $agent->get($activations_endpoint);

                if ($activations_resp->is_success) {
                    my $activations_data = decode_json($activations_resp->decoded_content);

                    # Sort activations to get the latest active versions for STAGING and PRODUCTION

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

                        $pm->finish;
                    }

                    # Retrieve and save staging version details if an active version is found
                    if (defined $staging_version) {
                        my $staging_rules_endpoint = "$baseurl/papi/v1/properties/$property_id/versions/$staging_version/rules?contractId=$contract_id&groupId=$group_id";
                        my $staging_rules_resp = $agent->get($staging_rules_endpoint);

                        if ($staging_rules_resp->is_success) {
                            my $staging_rules_content = $staging_rules_resp->decoded_content;
                            my $staging_file_path = File::Spec->catfile($property_dir, "staging.json");

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

                        }
                    }

                    # Retrieve and save production version details if an active version is found
                    if (defined $production_version) {
                        my $production_rules_endpoint = "$baseurl/papi/v1/properties/$property_id/versions/$production_version/rules?contractId=$contract_id&groupId=$group_id";
                        my $production_rules_resp = $agent->get($production_rules_endpoint);

                        if ($production_rules_resp->is_success) {
                            my $production_rules_content = $production_rules_resp->decoded_content;
                            my $production_file_path = File::Spec->catfile($property_dir, "production.json");

 view all matches for this distribution


Algorithm-ConstructDFA2

 view release on metacpan or  search on metacpan

t/03rand.t  view on Meta::CPAN

  while (1) {

    my @path = map { @$_ } $dbh->selectall_array($sth,
      {}, $start, $max_length);

    my @endpoints = indexes { $_ eq $final } @path;
    my $last_elem = random_element( @endpoints );

    next unless defined $last_elem;

    splice @path, $last_elem + 1;

t/03rand.t  view on Meta::CPAN

  while (1) {

    my @path = map { @$_ } $dbh->selectall_array($sth,
      {}, $start_id, $max_length);

    my @endpoints = indexes { %accepting{$_} } @path;
    my $last_elem = random_element( @endpoints );

    next unless defined $last_elem;

    splice @path, $last_elem + 1;

 view all matches for this distribution


Algorithm-Interval2Prefix

 view release on metacpan or  search on metacpan

Interval2Prefix.pm  view on Meta::CPAN


=over 4

=item *

With interval2prefix(), the endpoints of the interval must be the
same length (same number of digits in the particular number base)
for the results to make any sense.

=item *

 view all matches for this distribution


Algorithm-LBFGS

 view release on metacpan or  search on metacpan

lbfgs.c  view on Meta::CPAN


	/*
		The variables stx, fx, dgx contain the values of the step,
		function, and directional derivative at the best step.
		The variables sty, fy, dgy contain the value of the step,
		function, and derivative at the other endpoint of
		the interval of uncertainty.
		The variables stp, f, dg contain the values of the step,
		function, and derivative at the current step.
	*/
	stx = sty = 0.;

lbfgs.c  view on Meta::CPAN

 *
 *	The parameter x represents the step with the least function value.
 *	The parameter t represents the current step. This function assumes
 *	that the derivative at the point of x in the direction of the step.
 *	If the bracket is set to true, the minimizer has been bracketed in
 *	an interval of uncertainty with endpoints between x and y.
 *
 *	@param	x		The pointer to the value of one endpoint.
 *	@param	fx		The pointer to the value of f(x).
 *	@param	dx		The pointer to the value of f'(x).
 *	@param	y		The pointer to the value of another endpoint.
 *	@param	fy		The pointer to the value of f(y).
 *	@param	dy		The pointer to the value of f'(y).
 *	@param	t		The pointer to the value of the trial value, t.
 *	@param	ft		The pointer to the value of f(t).
 *	@param	dt		The pointer to the value of f'(t).

 view all matches for this distribution


Algorithm-Networksort

 view release on metacpan or  search on metacpan

lib/Algorithm/Networksort.pm  view on Meta::CPAN

	my $t = length sprintf("%b", $inputs - 1);

	my $lastbit = 1 << $t;

	#
	# $x and $y are the comparator endpoints.
	# We begin with values of zero and one.
	#
	my($x, $y) = (0, 1);

	while (1 == 1)

lib/Algorithm/Networksort.pm  view on Meta::CPAN

		my $clen = $to - $from;
		if ($cmptr[$clen] == 0)
		{
			$cmptr[$clen] = 1;

			my $endpoint = $vcoord[$to] - $vcoord[$from];

			$string .=
				qq(    <g id="C$clen$salt" $g_style >\n) .
				qq(      <desc>Comparator size $clen</desc>\n) .
				qq(      <line $l_style x1="0" y1="0" x2="0" y2="$endpoint" />\n);

			if ($c_radius > 0)
			{
				$string .= qq(      <circle $b_style cx="0" cy="0" r="$c_radius" />) .
					qq( <circle $e_style cx="0" cy="$endpoint" r="$c_radius" />\n);
			}

			$string .= qq(    </g>\n);
		}
	}

 view all matches for this distribution


Algorithm-Shape-RandomTree

 view release on metacpan or  search on metacpan

lib/Algorithm/Shape/RandomTree.pm  view on Meta::CPAN

    my $start_point = $parent->end_point;

    my $verb = $self->verbose;

    my ( $dx, $dy )       = $self->calc_new_deltas( $parent );
    my ( $x_end, $y_end ) = $self->calc_new_endpoints(
        $start_point, $dx, $dy
    );

    my $end_point = Algorithm::Shape::RandomTree::Branch::Point->new(
        x => $x_end, y => $y_end 

lib/Algorithm/Shape/RandomTree.pm  view on Meta::CPAN

        
    return( $new_dx, $new_dy );
}

# Calculate New End-points: ( by adding the deltas to the start-points )
sub calc_new_endpoints {
    my ( $self, $start_point, $dx, $dy ) = @_;

    my $x_end = $dx + $start_point->x;
    my $y_end = $dy + $start_point->y;

lib/Algorithm/Shape/RandomTree.pm  view on Meta::CPAN


    my $name = $parent->name;
    $verb && print "[make_branche] on parent: $name\n";

    my ( $dx, $dy )       = $self->calc_new_deltas( $parent );
    my ( $x_end, $y_end ) = $self->calc_new_endpoints(
        $start_point, $dx, $dy
    );

    my $end_point  = Algorithm::Shape::RandomTree::Branch::Point->new(
        x => $x_end, y => $y_end

lib/Algorithm/Shape/RandomTree.pm  view on Meta::CPAN


=head1 SUBROUTINES/METHODS

=head2 calc_new_deltas

=head2 calc_new_endpoints

=head2 calc_new_nodulation

=head2 create_branch

 view all matches for this distribution


Algorithm-TravelingSalesman-BitonicTour

 view release on metacpan or  search on metacpan

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN


=over 4

=item 1. Focus on optimal B<open> bitonic tours.

B<Optimal open bitonic tours> have endpoints (i,j) where C<< i < j < R >>, and
they are the building blocks of the optimal closed bitonic tour we're trying to
find.

An open bitonic tour, optimal or not, has these properties:

 * it's bitonic (a vertical line crosses the tour at most twice)
 * it's open (it has endpoints), which we call "i" and "j" (i < j)
 * all points to the left of "j" are visited by the tour
 * points i and j are endpoints (connected to exactly one edge)
 * all other points in the tour are connected to two edges

For a given set of points there may be many open bitonic tours with endpoints
(i,j), but we are only interested in the I<optimal> open tour--the tour with
the shortest length. Let's call this tour B<C<T(i,j)>>.

=item 2. Grok the (slightly) messy recurrence relation.

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN


=over 4

=item B<Finding C<T(0,5)>>

From our definition, C<T(0,5)> must have endpoints C<0> and C<5>, and must also
include all intermediate points C<1>-C<4>.  This means C<T(0,5)> is composed of
points C<0> through C<5> in order.  This is also the union of C<T(0,4)> and the
line segment C<4>-C<5>.

=item B<Finding C<T(1,5)>>

C<T(1,5)> has endpoints at C<1> and C<5>, and visits all points to the left of
C<5>.  To preserve the bitonicity of C<T(1,5)>, the only possibility for the
tour is the union of C<T(1,4)> and line segment C<4>-C<5>.  I have included a
short proof by contradiction of this in the source code.

=begin comment

Proof by contradiction:

 1. Assume the following:
    * T(1,5) is an optimal open bitonic tour having endpoints 1 and 5.
    * Points 4 and 5 are not adjacent in the tour, i.e. the final segment in
      the tour joins points "P" and 5, where "P" is to the left of point 4.
 2. Since T(1,5) is an optimal open bitonic tour, point 4 is included in the
    middle of the tour, not at an endpoint, and is connected to two edges.
 3. Since 4 is not connected to 5, both its edges connect to points to its
    left.
 4. Combined with the segment from 5 to P, a vertical line immediately to the
    left of point 4 must cross at least three line segments, thus our proposed
    T(1,5) is not bitonic.

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN

Our logic for finding C<T(1,5)> applies to these cases as well.

=item B<Finding C<T(4,5)>>

Tour C<T(4,5)> breaks the pattern seen in C<T(0,5)> through C<T(3,5)>, because
the leftmost point (point 4) must be an endpoint in the tour.  Via proof by
contradiction similar to the above, our choices for constructing C<T(4,5)> are:

    T(0,4) + line segment from 0 to 5
    T(1,4) + line segment from 1 to 5
    T(2,4) + line segment from 2 to 5

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN


Find the length of the optimal complete (closed) bitonic tour.  This is done by
choosing the shortest tour from the set of all possible complete tours.

A possible closed tour is composed of a partial tour with rightmost point C<R>
as one of its endpoints plus the final return segment from R to the other
endpoint of the tour.

    T(0,R) + delta(0,R)
    T(1,R) + delta(1,R)
    ...
    T(i,R) + delta(i,R)

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN

}

=head2 $obj->optimal_open_tour_adjacent($i,$j)

Uses information about optimal open tours to the left of <$j> to find the
optimal tour with endpoints (C<$i>, C<$j>).

This method handles the case where C<$i> and C<$j> are adjacent, i.e.  C<< $i =
$j - 1 >>.  In this case there are many possible bitonic tours, all going from
C<$i> to "C<$x>" to C<$j>.  All points C<$x> in the range C<(0 .. $i - 1)> are
examined to find the optimal tour.

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN

}

=head2 $obj->optimal_open_tour_nonadjacent($i,$j)

Uses information about optimal open tours to the left of <$j> to find the
optimal tour with endpoints (C<$i>, C<$j>).

This method handles the case where C<$i> and C<$j> are not adjacent, i.e.  C<<
$i < $j - 1 >>.  In this case there is only one bitonic tour possible, going
from C<$i> to C<$j-1> to C<$j>.

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN



=head2 $b->tour($i,$j)

Returns the data structure associated with the optimal open bitonic tour with
endpoints (C<$i>, C<$j>).

=cut

sub tour {
    my ($self, $i, $j) = @_;

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN

    return $self->_tour->{$i}{$j};
}

=head2 $b->tour_length($i, $j, [$len])

Returns the length of the optimal open bitonic tour with endpoints (C<$i>,
C<$j>).  If C<$len> is specified, set the length to C<$len>.

=cut

sub tour_length {

lib/Algorithm/TravelingSalesman/BitonicTour.pm  view on Meta::CPAN

}

=head2 $b->tour_points($i, $j, [@points])

Returns an array containing the indices of the points in the optimal open
bitonic tour with endpoints (C<$i>, C<$j>).

If C<@points> is specified, set the endpoints to C<@points>.

=cut

sub tour_points {
    my $self = shift;

 view all matches for this distribution


Alien-Build-Plugin-Download-GitHub

 view release on metacpan or  search on metacpan

lib/Alien/Build/Plugin/Download/GitHub.pm  view on Meta::CPAN

  else
  {
    $meta->add_requires('configure' => 'Alien::Build::Plugin::Download::GitHub' => 0 );
  }

  my $endpoint = $self->tags_only ? 'tags' : 'releases' ;
  $meta->prop->{start_url} ||= "https://api.github.com/repos/@{[ $self->github_user ]}/@{[ $self->github_repo ]}/$endpoint";

  $meta->apply_plugin('Download',
    prefer  => $self->prefer,
    version => $self->version,
  );

lib/Alien/Build/Plugin/Download/GitHub.pm  view on Meta::CPAN

=back

=head2 tags_only

Boolean value for those repositories that do not upgrade their tags to releases.
There are two different endpoints. One for
L<releases|https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository>
and one for simple L<tags|https://developer.github.com/v3/repos/#list-tags>. The
default is to interrogate the former for downloads. Passing a true value for
L</"tags_only"> interrogates the latter for downloads.

 view all matches for this distribution


Alien-FreeImage

 view release on metacpan or  search on metacpan

src/Source/LibPNG/png.c  view on Meta::CPAN


   return 0;
}

static int
png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta)
{
   /* Allow an error of +/-0.01 (absolute value) on each chromaticity */
   if (PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) ||
       PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) ||
       PNG_OUT_OF_RANGE(xy1->redx,   xy2->redx,  delta) ||

src/Source/LibPNG/png.c  view on Meta::CPAN

png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy)
{
   int result;
   png_xy xy_test;

   /* As a side-effect this routine also returns the XYZ endpoints. */
   result = png_XYZ_from_xy(XYZ, xy);
   if (result != 0)
      return result;

   result = png_xy_from_XYZ(&xy_test, XYZ);
   if (result != 0)
      return result;

   if (png_colorspace_endpoints_match(xy, &xy_test,
       5/*actually, the math is pretty accurate*/) != 0)
      return 0;

   /* Too much slip */
   return 1;

src/Source/LibPNG/png.c  view on Meta::CPAN


   XYZtemp = *XYZ;
   return png_colorspace_check_xy(&XYZtemp, xy);
}

/* Used to check for an endpoint match against sRGB */
static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */
{
   /* color      x       y */
   /* red   */ 64000, 33000,
   /* green */ 30000, 60000,

src/Source/LibPNG/png.c  view on Meta::CPAN

       (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
   {
      /* The end points must be reasonably close to any we already have.  The
       * following allows an error of up to +/-.001
       */
      if (png_colorspace_endpoints_match(xy, &colorspace->end_points_xy,
          100) == 0)
      {
         colorspace->flags |= PNG_COLORSPACE_INVALID;
         png_benign_error(png_ptr, "inconsistent chromaticities");
         return 0; /* failed */

src/Source/LibPNG/png.c  view on Meta::CPAN

   colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS;

   /* The end points are normally quoted to two decimal digits, so allow +/-0.01
    * on this test.
    */
   if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000) != 0)
      colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB;

   else
      colorspace->flags &= PNG_COLORSPACE_CANCEL(
         PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);

src/Source/LibPNG/png.c  view on Meta::CPAN


   return 0; /* failed */
}

int /* PRIVATE */
png_colorspace_set_endpoints(png_const_structrp png_ptr,
   png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)
{
   png_XYZ XYZ = *XYZ_in;
   png_xy xy;

src/Source/LibPNG/png.c  view on Meta::CPAN


   /* If the standard sRGB cHRM chunk does not match the one from the PNG file
    * warn but overwrite the value with the correct one.
    */
   if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&
      !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,
         100))
      png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
         PNG_CHUNK_ERROR);

   /* This check is just done for the error reporting - the routine always

src/Source/LibPNG/png.c  view on Meta::CPAN


   /* intent: bugs in GCC force 'int' to be used as the parameter type. */
   colorspace->rendering_intent = (png_uint_16)intent;
   colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT;

   /* endpoints */
   colorspace->end_points_xy = sRGB_xy;
   colorspace->end_points_XYZ = sRGB_XYZ;
   colorspace->flags |=
      (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);

 view all matches for this distribution


Alien-OpenJDK

 view release on metacpan or  search on metacpan

alienfile  view on Meta::CPAN

  }
}

sub do_dist_temurin {
  # API documentation: <https://github.com/adoptium/api.adoptium.net>
  my $endpoint_server = 'https://api.adoptium.net';
  start_url $endpoint_server . '/v3/info/available_releases';

  # Perl to API
  my %os_mapping = (
      linux   => 'linux',
      MSWin32 => 'windows',

alienfile  view on Meta::CPAN


      my $release = $available_releases->{most_recent_lts};
      $build->log( "Using release $release" );

      my $assets = _decode( $orig->($build,
        $endpoint_server
        .  "/v3/assets/latest/${release}/hotspot"
        . "?image_type=jdk"
        . "&os=${os}"
        . "&architecture=${arch}"
        . "&vendor=eclipse"

 view all matches for this distribution


Alien-SVN

 view release on metacpan or  search on metacpan

src/subversion/subversion/include/private/svn_mergeinfo_private.h  view on Meta::CPAN

/* Set *YOUNGEST_REV and *OLDEST_REV to the youngest and oldest revisions
   found in the rangelists within MERGEINFO.  Note that *OLDEST_REV is
   exclusive and *YOUNGEST_REV is inclusive.  If MERGEINFO is NULL or empty
   set *YOUNGEST_REV and *OLDEST_REV to SVN_INVALID_REVNUM. */
svn_error_t *
svn_mergeinfo__get_range_endpoints(svn_revnum_t *youngest_rev,
                                   svn_revnum_t *oldest_rev,
                                   svn_mergeinfo_t mergeinfo,
                                   apr_pool_t *pool);

/* Set *FILTERED_MERGEINFO to a deep copy of MERGEINFO, allocated in

 view all matches for this distribution


Alien-SwaggerUI

 view release on metacpan or  search on metacpan

share/swagger-ui-bundle.js.map  view on Meta::CPAN

{"version":3,"sources":["webpack://SwaggerUIBundle/webpack/universalModuleDefinition","webpack://SwaggerUIBundle/webpack/bootstrap","webpack://SwaggerUIBundle/./node_modules/react/react.js","webpack://SwaggerUIBundle/./node_modules/immutable/dist/imm...

 view all matches for this distribution


Alien-Web-HalBrowser

 view release on metacpan or  search on metacpan

share/vendor/js/backbone.js  view on Meta::CPAN

      if (!options.wait) destroy();
      return xhr;
    },

    // Default URL for the model's representation on the server -- if you're
    // using Backbone's restful methods, override this to change the endpoint
    // that will be called.
    url: function() {
      var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError();
      if (this.isNew()) return base;
      return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id);

 view all matches for this distribution


Alien-XGBoost

 view release on metacpan or  search on metacpan

xgboost/dmlc-core/src/io/s3_filesys.cc  view on Meta::CPAN

  if (region_name == "us-east-1") {
    return "s3.amazonaws.com";
  } else if (region_name == "cn-north-1") {
    return "s3.cn-north-1.amazonaws.com.cn";
  } else {
    std::string result_endpoint = std::string("s3-");
    result_endpoint.append(region_name);
    result_endpoint.append(".amazonaws.com");
    return result_endpoint;
  }
}


// useful callback for reading memory

 view all matches for this distribution


Alien-cares

 view release on metacpan or  search on metacpan

libcares/ares_platform.c  view on Meta::CPAN

{"swdtp",              {NULL}, 10104, "udp"},
{"bctp-server",        {NULL}, 10107, "tcp"},
{"bctp-server",        {NULL}, 10107, "udp"},
{"nmea-0183",          {NULL}, 10110, "tcp"},
{"nmea-0183",          {NULL}, 10110, "udp"},
{"netiq-endpoint",     {NULL}, 10113, "tcp"},
{"netiq-endpoint",     {NULL}, 10113, "udp"},
{"netiq-qcheck",       {NULL}, 10114, "tcp"},
{"netiq-qcheck",       {NULL}, 10114, "udp"},
{"netiq-endpt",        {NULL}, 10115, "tcp"},
{"netiq-endpt",        {NULL}, 10115, "udp"},
{"netiq-voipa",        {NULL}, 10116, "tcp"},

 view all matches for this distribution


Alien-libsecp256k1

 view release on metacpan or  search on metacpan

libsecp256k1/build/src/libsecp256k1-config-version.cmake  view on Meta::CPAN

    set(CVF_VERSION_MAJOR "0.6.0")
    set(CVF_VERSION_MINOR "")
  endif()

  if(PACKAGE_FIND_VERSION_RANGE)
    # both endpoints of the range must have the expected major and minor versions
    math (EXPR CVF_VERSION_MINOR_NEXT "${CVF_VERSION_MINOR} + 1")
    if (NOT (PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
          AND PACKAGE_FIND_VERSION_MIN_MINOR STREQUAL CVF_VERSION_MINOR)
        OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE"
            AND NOT (PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR

 view all matches for this distribution


Alien-nghttp3

 view release on metacpan or  search on metacpan

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

#define NGHTTP3_ERR_H3_SETTINGS_ERROR -608
/**
 * @macro
 *
 * :macro:`NGHTTP3_ERR_H3_STREAM_CREATION_ERROR` indicates that a
 * remote endpoint attempts to create a new stream which is not
 * allowed.
 */
#define NGHTTP3_ERR_H3_STREAM_CREATION_ERROR -609
/**
 * @macro
 *
 * :macro:`NGHTTP3_ERR_H3_EXCESSIVE_LOAD` indicates that a local
 * endpoint detected that its remote endpoint is exhibiting a behavior
 * that might generating excessive load.
 */
#define NGHTTP3_ERR_H3_EXCESSIVE_LOAD -610
/**
 * @macro
 *
 * :macro:`NGHTTP3_ERR_FATAL` indicates that error codes less than
 * this value is fatal error.  When this error is returned, an
 * endpoint should drop connection immediately.
 */
#define NGHTTP3_ERR_FATAL -900
/**
 * @macro
 *

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN


/**
 * @function
 *
 * `nghttp3_qpack_decoder_set_max_concurrent_streams` tells |decoder|
 * the maximum number of concurrent streams that a remote endpoint can
 * open, including both bidirectional and unidirectional streams which
 * potentially receive QPACK encoded HEADERS frame.  This value is
 * used as a hint to limit the length of decoder stream.
 */
NGHTTP3_EXTERN void

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

  /* The following fields have been added since
     NGHTTP3_SETTINGS_V3. */
  /**
   * :member:`glitch_ratelim_burst` is the maximum number of tokens
   * available to "glitch" rate limiter.  "glitch" is a suspicious
   * activity from a remote endpoint.  If detected, certain amount of
   * tokens are consumed.  If no tokens are available to consume, the
   * connection is closed.  The rate of token generation is specified
   * by :member:`glitch_ratelim_rate`.  This feature is enabled only
   * when `nghttp3_conn_read_stream2` is used.
   *

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

/**
 * @functypedef
 *
 * :type:`nghttp3_acked_stream_data` is a callback function which is
 * invoked when data sent on stream denoted by |stream_id| supplied
 * from application is acknowledged by remote endpoint.  The number of
 * bytes acknowledged is given in |datalen|.
 *
 * The implementation of this callback must return 0 if it succeeds.
 * Returning :macro:`NGHTTP3_ERR_CALLBACK_FAILURE` will return to the
 * caller immediately.  Any values other than 0 is treated as

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN


/**
 * @functypedef
 *
 * :type:`nghttp3_shutdown` is a callback function which is invoked
 * when a shutdown is initiated by the remote endpoint. For client,
 * |id| contains a stream ID of a client initiated stream, for server,
 * it contains a push ID. All client streams with stream ID, or pushes
 * with push ID equal to, or larger than |ID| are guaranteed to not be
 * processed by the remote endpoint.  Note that libnghttp3 does not
 * implement Server Push.
 *
 * Parameter |id| for client can contain a special value
 * :macro:`NGHTTP3_SHUTDOWN_NOTICE_STREAM_ID`, and for server it can
 * contain special value
 * :macro:`NGHTTP3_SHUTDOWN_NOTICE_PUSH_ID`. These values signal
 * request for graceful shutdown of the connection, triggered by
 * remote endpoint's invocation of
 * `nghttp3_conn_submit_shutdown_notice`.
 *
 * It is possible that this callback is invoked multiple times on a
 * single connection, however the |id| can only stay the same or
 * decrease, never increase.

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

 */
typedef struct nghttp3_callbacks {
  /**
   * :member:`acked_stream_data` is a callback function which is
   * invoked when data sent on a particular stream have been
   * acknowledged by a remote endpoint.
   */
  nghttp3_acked_stream_data acked_stream_data;
  /**
   * :member:`stream_close` is a callback function which is invoked
   * when a particular stream has closed.

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

   * RESET_STREAM).
   */
  nghttp3_reset_stream reset_stream;
  /**
   * :member:`shutdown` is a callback function which is invoked when
   * the remote endpoint has signalled initiation of connection
   * shutdown.
   */
  nghttp3_shutdown shutdown;
  /**
   * .. warning::

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

  /**
   * :member:`rand` is a callback function which is invoked when
   * unpredictable data are needed.  Although this field is optional
   * due to the backward compatibility, it is recommended to specify
   * this field to harden the runtime behavior against suspicious
   * activities of a remote endpoint.
   *
   * .. version-added:: 1.11.0
   */
  nghttp3_rand rand;
  /* The following fields have been added since

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

 * control credit (both stream and connection) of underlying QUIC
 * connection by that amount.  It does not include the amount of data
 * carried by DATA frame which contains application data (excluding
 * any control or QPACK unidirectional streams).  See
 * :type:`nghttp3_recv_data` to handle those bytes.  If |fin| is
 * nonzero, this is the last data from remote endpoint in this stream.
 *
 * This function returns the number of bytes consumed, or one of the
 * following negative error codes:
 *
 * :macro:`NGHTTP3_ERR_NOMEM`

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

 * control credit (both stream and connection) of underlying QUIC
 * connection by that amount.  It does not include the amount of data
 * carried by DATA frame which contains application data (excluding
 * any control or QPACK unidirectional streams).  See
 * :type:`nghttp3_recv_data` to handle those bytes.  If |fin| is
 * nonzero, this is the last data from remote endpoint in this stream.
 * |ts| is the current timestamp, and must be non-decreasing.  It
 * should be obtained from the clock that is steadily increasing.
 *
 * This function returns the number of bytes consumed, or one of the
 * following negative error codes:

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN


/**
 * @function
 *
 * `nghttp3_conn_set_max_concurrent_streams` tells |conn| the maximum
 * number of concurrent streams that a remote endpoint can open,
 * including both bidirectional and unidirectional streams which
 * potentially receive QPACK encoded HEADERS frame.  This value is
 * used as a hint to limit the internal resource consumption.
 */
NGHTTP3_EXTERN void

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

                                                size_t nvlen);

/**
 * @function
 *
 * `nghttp3_conn_submit_shutdown_notice` notifies the other endpoint
 * to stop creating new stream.  After a couple of RTTs later, call
 * `nghttp3_conn_shutdown` to start graceful shutdown.
 *
 * This function returns 0 if it succeeds, or one of the following
 * negative error codes:

vendor/nghttp3-1.18.0/lib/includes/nghttp3/nghttp3.h  view on Meta::CPAN

/**
 * @function
 *
 * `nghttp3_conn_shutdown` starts graceful shutdown.  It should be
 * called after `nghttp3_conn_submit_shutdown_notice` and a couple of
 * RTTs.  After calling this function, the local endpoint starts
 * rejecting new incoming streams.  The existing streams are processed
 * normally.  See also `nghttp3_conn_is_drained`.
 *
 * This function returns 0 if it succeeds, or one of the following
 * negative error codes:

 view all matches for this distribution


Alien-ngtcp2

 view release on metacpan or  search on metacpan

vendor/picotls/include/picotls.h  view on Meta::CPAN

    /**
     * if application-data (e.g., payload) should be emitted as well
     */
    volatile unsigned may_include_appdata : 1;
    /**
     * endpoints that want to disable logging entirely can provide this value to the loggers
     */
    ptls_log_conn_state_t dummy_conn_state;
    /**
     * generation counter that is incremented whenever the state of loggers change; see `st_ptls_log_state_t::generation`
     */

 view all matches for this distribution


Alien-uv

 view release on metacpan or  search on metacpan

libuv/docs/src/errors.rst  view on Meta::CPAN


    read-only file system

.. c:macro:: UV_ESHUTDOWN

    cannot send after transport endpoint shutdown

.. c:macro:: UV_ESPIPE

    invalid seek

 view all matches for this distribution


Alvis-QueryFilter

 view release on metacpan or  search on metacpan

t/test/resources/terms  view on Meta::CPAN

degradation intermediate 	degradation intermediate
degradative enzyme 	degradative enzyme
degradative enzyme synthesis 	degradative enzyme synthesis
deletion analysis 	deletion analysis
deletion derivative 	deletion derivative
deletion endpoints 	deletion endpoints
deletion formation 	deletion formation
deletion frequency 	deletion frequency
deletion from a sequence 	sequence deletion
deletion mapping 	deletion mapping
deletion mapping experiment 	deletion mapping experiment

 view all matches for this distribution


Amazon-CloudFront-Thin

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

Revision history for Amazon-CloudFront-Thin

0.05    2019-04-20
    - update API endpoints (Chris Compton)
    - support filenames containing ']]>'
    - updated CloudFront documentation links

0.04    2015-12-29
    - Docs on handling unicode paths (Devin Ceartas)

 view all matches for this distribution


Amazon-CreatorsAPI

 view release on metacpan or  search on metacpan

lib/Amazon/CreatorsAPI.pm  view on Meta::CPAN

        credential_version
        partner_tag
        marketplace
        ua
        auth_manager
        operation_endpoint
    /],
);

our $VERSION = '0.01';

lib/Amazon/CreatorsAPI.pm  view on Meta::CPAN

            $credential_id,
            $credential_secret,
            $credential_version,
            $opt,
        ),
        operation_endpoint => $opt->{operation_endpoint} || 'https://creatorsapi.amazon/catalog/v1',
    }, $class;
}

sub get_browse_nodes {
    return shift->operation('getBrowseNodes', @_);

lib/Amazon/CreatorsAPI.pm  view on Meta::CPAN

    my $operation = shift || '';
    my $params    = shift || +{};

    my $res = $self->ua->request(
        'POST',
        $self->operation_endpoint . '/' . $operation,
        {
            'headers' => {
                'Authorization' => $self->_auth_header,
                'Content-Type' => 'application/json',
                'x-marketplace' => $self->marketplace,

 view all matches for this distribution


( run in 5.027 seconds using v1.01-cache-2.11-cpan-99fa8243a42 )