RubyGems - javonet-ruby-sdk - Versions diffs - 2.4.9 → 2.4.11 - Mend

javonet-ruby-sdk 2.4.9 → 2.4.11

Files changed (1457) hide show

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/FFI/Platypus/API.pm DELETED Viewed

@@ -1,293 +0,0 @@
-package FFI::Platypus::API;
-use strict;
-use warnings;
-use 5.008004;
-use FFI::Platypus;
-use Exporter qw( import );
-our @EXPORT = grep /^arguments_/, keys %FFI::Platypus::API::;
-# ABSTRACT: Platypus arguments and return value API for custom types
-our $VERSION = '2.09'; # VERSION
-1;
-__END__
-=pod
-=encoding UTF-8
-=head1 NAME
-FFI::Platypus::API - Platypus arguments and return value API for custom types
-=head1 VERSION
-version 2.09
-=head1 SYNOPSIS
- package FFI::Platypus::Type::MyCustomType;
- use FFI::Platypus::API;
- sub ffi_custom_type_api_1
- {
-   {
-     native_type => 'uint32',
-     perl_to_native => sub {
-       my($value, $i) = @_;
-       # Translates ($value) passed in from Perl
-       # into ($value+1, $value+2)
-       arguments_set_uint32($i, $value+1);
-       arguments_set_uint32($i+1, $value+2);
-     },
-     argument_count => 2,
-   }
- }
-=head1 DESCRIPTION
-B<NOTE>: I added this interface early on to L<FFI::Platypus>, but haven't
-used it much, generally finding function wrappers to be a more powerful
-(although possibly not as fast) interface.  It has thus not been
-tested as much as the rest of Platypus.  If you feel the need to use
-this interface please coordinate with the Platypus developers.
-The custom types API for L<FFI::Platypus> allows you to set multiple C
-arguments from a single Perl argument as a common type.  This is
-sometimes useful for pointer / size pairs which are a common pattern in
-C, but are usually represented by a single value (a string scalar) in
-Perl.
-The custom type API is somewhat experimental, and you should expect some
-changes as needs arise (I won't break compatibility lightly, however).
-=head1 FUNCTIONS
-These functions are only valid within a custom type callback.
-=head2 arguments_count
- my $count = argument_count;
-Returns the total number of native arguments.
-=head2 arguments_get_sint8
- my $sint8 = arguments_get_sint8 $i;
-Get the 8 bit signed integer argument from position I<$i>.
-=head2 arguments_set_sint8
- arguments_set_sint8 $i, $sint8;
-Set the 8 bit signed integer argument at position I<$i> to I<$sint8>.
-=head2 arguments_get_uint8
- my $uint8 = arguments_get_uint8 $i;
-Get the 8 bit unsigned integer argument from position I<$i>.
-=head2 arguments_set_uint8
- arguments_set_uint8 $i, $uint8;
-Set the 8 bit unsigned integer argument at position I<$i> to I<$uint8>.
-=head2 arguments_get_sint16
- my $sint16 = arguments_get_sint16 $i;
-Get the 16 bit signed integer argument from position I<$i>.
-=head2 arguments_set_sint16
- arguments_set_sint16 $i, $sint16;
-Set the 16 bit signed integer argument at position I<$i> to I<$sint16>.
-=head2 arguments_get_uint16
- my $uint16 = arguments_get_uint16 $i;
-Get the 16 bit unsigned integer argument from position I<$i>.
-=head2 arguments_set_uint16
- arguments_set_uint16 $i, $uint16;
-Set the 16 bit unsigned integer argument at position I<$i> to I<$uint16>.
-=head2 arguments_get_sint32
- my $sint32 = arguments_get_sint32 $i;
-Get the 32 bit signed integer argument from position I<$i>.
-=head2 arguments_set_sint32
- arguments_set_sint32 $i, $sint32;
-Set the 32 bit signed integer argument at position I<$i> to I<$sint32>.
-=head2 arguments_get_uint32
- my $uint32 = arguments_get_uint32 $i;
-Get the 32 bit unsigned integer argument from position I<$i>.
-=head2 arguments_set_uint32
- arguments_set_uint32 $i, $uint32;
-Set the 32 bit unsigned integer argument at position I<$i> to I<$uint32>.
-=head2 arguments_get_sint64
- my $sint64 = arguments_get_sint64 $i;
-Get the 64 bit signed integer argument from position I<$i>.
-=head2 arguments_set_sint64
- arguments_set_sint64 $i, $sint64;
-Set the 64 bit signed integer argument at position I<$i> to I<$sint64>.
-=head2 arguments_get_uint64
- my $uint64 = arguments_get_uint64 $i;
-Get the 64 bit unsigned integer argument from position I<$i>.
-=head2 arguments_set_uint64
- arguments_set_uint64 $i, $uint64;
-Set the 64 bit unsigned integer argument at position I<$i> to I<$uint64>.
-=head2 arguments_get_float
- my $float = arguments_get_float $i;
-Get the floating point argument from position I<$i>.
-=head2 arguments_set_float
- arguments_set_float $i, $float;
-Set the floating point argument at position I<$i> to I<$float>
-=head2 arguments_get_double
- my $double = arguments_get_double $i;
-Get the double precision floating point argument from position I<$i>.
-=head2 arguments_set_double
- arguments_set_double $i, $double;
-Set the double precision floating point argument at position I<$i> to
-I<$double>
-=head2 arguments_get_pointer
- my $pointer = arguments_get_pointer $i;
-Get the pointer argument from position I<$i>.
-=head2 arguments_set_pointer
- arguments_set_pointer $i, $pointer;
-Set the pointer argument at position I<$i> to I<$pointer>.
-=head2 arguments_get_string
- my $string = arguments_get_string $i;
-Get the string argument from position I<$i>.
-=head2 arguments_set_string
- arguments_set_string $i, $string;
-Set the string argument at position I<$i> to I<$string>.
-=head1 SEE ALSO
-=over 4
-=item L<FFI::Platypus>
-=back
-Examples of use:
-=over 4
-=item L<FFI::Platypus::Type::PointerSizeBuffer>
-=back
-=head1 AUTHOR
-Author: Graham Ollis E<lt>plicease@cpan.orgE<gt>
-Contributors:
-Bakkiaraj Murugesan (bakkiaraj)
-Dylan Cali (calid)
-pipcet
-Zaki Mughal (zmughal)
-Fitz Elliott (felliott)
-Vickenty Fesunov (vyf)
-Gregor Herrmann (gregoa)
-Shlomi Fish (shlomif)
-Damyan Ivanov
-Ilya Pavlov (Ilya33)
-Petr Písař (ppisar)
-Mohammad S Anwar (MANWAR)
-Håkon Hægland (hakonhagland, HAKONH)
-Meredith (merrilymeredith, MHOWARD)
-Diab Jerius (DJERIUS)
-Eric Brine (IKEGAMI)
-szTheory
-José Joaquín Atria (JJATRIA)
-Pete Houston (openstrike, HOUSTON)
-Lukas Mai (MAUKE)
-=head1 COPYRIGHT AND LICENSE
-This software is copyright (c) 2015-2022 by Graham Ollis.
-This is free software; you can redistribute it and/or modify it under
-the same terms as the Perl 5 programming language system itself.
-=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/FFI/Platypus/Buffer.pm DELETED Viewed

@@ -1,366 +0,0 @@
-package FFI::Platypus::Buffer;
-use strict;
-use warnings;
-use 5.008004;
-use FFI::Platypus;
-use Exporter qw( import );
-our @EXPORT = qw( scalar_to_buffer buffer_to_scalar );
-our @EXPORT_OK = qw ( scalar_to_pointer grow set_used_length window );
-# ABSTRACT: Convert scalars to C buffers
-our $VERSION = '2.09'; # VERSION
-use constant _incantation =>
-  $^O eq 'MSWin32' && do { require Config; $Config::Config{archname} =~ /MSWin32-x64/ }
-  ? 'Q'
-  : 'L!';
-sub scalar_to_buffer ($)
-{
-  (unpack(_incantation, pack 'P', $_[0]), do { use bytes; length $_[0] });
-}
-sub scalar_to_pointer ($)
-{
-  unpack(_incantation, pack 'P', $_[0]);
-}
-sub buffer_to_scalar ($$)
-{
-  unpack 'P'.$_[1], pack _incantation, defined $_[0] ? $_[0] : 0;
-}
-1;
-__END__
-=pod
-=encoding UTF-8
-=head1 NAME
-FFI::Platypus::Buffer - Convert scalars to C buffers
-=head1 VERSION
-version 2.09
-=head1 SYNOPSIS
- use FFI::Platypus::Buffer;
- my($pointer, $size) = scalar_to_buffer $scalar;
- my $scalar2 = buffer_to_scalar $pointer, $size;
-=head1 DESCRIPTION
-A common pattern in C is to pass a "buffer" or region of memory into a
-function with a pair of arguments, an opaque pointer and the size of the
-memory region.  In Perl the equivalent structure is a scalar containing
-a string of bytes.  This module provides portable functions for
-converting a Perl string or scalar into a buffer and back.
-These functions are implemented using L<pack and unpack|perlpacktut> and
-so they should be relatively fast.
-Both functions are exported by default, but you can explicitly export
-one or neither if you so choose.
-A better way to do this might be with custom types see
-L<FFI::Platypus::API> and L<FFI::Platypus::Type>.  These functions were
-taken from the now obsolete L<FFI::Util> module, as they may be useful
-in some cases.
-B<Caution>: This module provides great power in the way that you
-interact with C code, but with that power comes great responsibility.
-Since you are dealing with blocks of memory you need to take care to
-understand the underlying ownership model of these pointers.
-=head1 FUNCTIONS
-=head2 scalar_to_buffer
- my($pointer, $size) = scalar_to_buffer $scalar;
-Convert a string scalar into a buffer.  Returned in order are a pointer
-to the start of the string scalar's memory region and the size of the
-region.
-You should NEVER try to free C<$pointer>.
-When you pass this pointer and size into a C function, it has direct
-access to the data stored in your scalar, so it is important that you
-not resize or free the scalar while it is in use by the C code.  Typically
-if you are passing a buffer into a C function which reads or writes to
-the buffer, but does not keep the pointer for later use you are okay.
-If the buffer is in use long term by the C code, then you should consider
-copying the buffer instead.  For example:
- use FFI::Platypus::Buffer qw( scalar_to_buffer );
- use FFI::Platypus::Memory qw( malloc memcpy free )
- my($ptr, $size) = scalar_to_buffer $string;
- c_function_that_does_not_keep_ptr( $ptr, $size); # okay
- my($ptr, $size) = scalar_to_buffer $string;
- my $ptr_copy = malloc($size);
- memcpy($ptr_copy, $ptr, $size);
- c_function_that_DOES_keep_ptr( $ptr_copy, $size); # also okay
- ...
- # later when you know that the c code is no longer using the pointer
- # Since you allocated the copy, you are responsible for free'ing it.
- free($ptr_copy);
-=head2 scalar_to_pointer
- my $pointer = scalar_to_pointer $scalar;
-Get the pointer to the scalar.  (Similar to C<scalar_to_buffer> above, but
-the size of the scalar is not computed or returned).
-Not exported by default, but may be exported on request.
-=head2 buffer_to_scalar
- my $scalar = buffer_to_scalar $pointer, $size;
-Convert the buffer region defined by the pointer and size into a string
-scalar.
-Because of the way memory management works in Perl, the buffer is copied
-from the buffer into the scalar.  If this pointer was returned from C
-land, then you should only free it if you allocated it.
-=head2 grow
- grow $scalar, $size, \%options;
-Ensure that the scalar can contain at least C<$size> bytes.  The
-following are recognized:
-=over
-=item clear => I<boolean>
-If true, C<$scalar> is cleared prior to being enlarged.  This
-avoids copying the existing contents to the reallocated memory
-if they are not needed.
-  For example, after
-   $scalar = "my string";
-   grow $scalar, 100, { clear => 0 };
-C<$scalar == "my string">, while after
-   $scalar = "my string";
-   grow $scalar, 100;
-C<length($scalar) == 0>
-It defaults to C<true>.
-=item set_length => I<boolean>
-If true, the length of the I<string> in the C<$scalar> is set to C<$size>.
-(See the discussion in L</set_used_length>.)  This is useful if a
-foreign function writes exactly C<$size> bytes to C<$scalar>, as it avoids
-a subsequent call to C<set_used_length>.  Contrast this
-  grow my $scalar, 100;
-  read_exactly_100_bytes_into_scalar( scalar_to_pointer($scalar) );
-  @chars = unpack( 'c*', $scalar );
-with this:
-  grow my $scalar, 100, { set_length => 0 };
-  read_exactly_100_bytes_into_scalar( scalar_to_pointer($scalar) );
-  set_used_length( $scalar, 100 );
-  @chars = unpack( 'c*', $scalar );
-It defaults to C<true>.
-=back
-Any pointers obtained with C<scalar_to_pointer> or C<scalar_to_buffer>
-are no longer valid after growing the scalar.
-Not exported by default, but may be exported on request.
-=head2 set_used_length
- set_used_length $scalar, $length;
-Update Perl's notion of the length of the string in the scalar. A
-string scalar keeps track of two lengths: the number of available
-bytes and the number of used bytes.  When a string scalar is
-used as a buffer by a foreign function, it is necessary to indicate
-to Perl how many bytes were actually written to it so that Perl's
-string functions (such as C<substr> or C<unpack>) will work correctly.
-If C<$length> is larger than what the scalar can hold, it is set to the
-maximum possible size.
-In the following example, the foreign routine C<read_doubles>
-may fill the buffer with up to a set number of doubles, returning the
-number actually written.
-  my $sizeof_double = $ffi->sizeof( 'double' );
-  my $max_doubles = 100;
-  my $max_length = $max_doubles * $sizeof_double;
-  my $buffer;                   # length($buffer) == 0
-  grow $buffer, $max_length;    # length($buffer) is still  0
-  my $pointer = scalar_to_pointer($buffer);
-  my $num_read = read_doubles( $pointer, $max_doubles );
-                                # length($buffer) is still == 0
-  set_used_length $buffer, $num_read * $sizeof_double;
-                                # length($buffer) is finally != 0
-  # unpack the native doubles into a Perl array
-  my @doubles = unpack( 'd*', $buffer );  # @doubles == $num_read
-Not exported by default, but may be exported on request.
-=head2 window
- window $scalar, $pointer;
- window $scalar, $pointer, $size;
- window $scalar, $pointer, $size, $utf8;
-This makes the scalar a read-only window into the arbitrary region of
-memory defined by C<$pointer>, pointing to the start of the region
-and C<$size>, the size of the region.  If C<$size> is omitted then
-it will assume a C style string and use the C C<strlen> function to
-determine the size (the terminating C<'\0'> will not be included).
-This can be useful if you have a C function that returns a buffer
-pair (pointer, size), and want to access it from Perl without having
-to copy the data.  This can also be useful when interfacing with
-programming languages that store strings as a address/length pair
-instead of a pointer to null-terminated sequence of bytes.
-You can specify C<$utf8> to set the UTF-8 flag on the scalar.  Note
-that the behavior of setting the UTF-8 flag on a buffer that does
-not contain UTF-8 as understood by the version of Perl that you are
-running is undefined.
-I<Hint>: If you have a buffer that needs to be free'd by C once the
-scalar falls out of scope you can use L<Variable::Magic> to apply
-magic to the scalar and free the pointer once it falls out of scope.
- use FFI::Platypus::Buffer qw( scalar_to_pointer );
- use FFI::Platypus::Memory qw( strdup free );
- use Variable::Magic qw( wizard cast );
- my $free_when_out_of_scope = wizard(
-   free => sub {
-     my $ptr = scalar_to_pointer ${$_[0]};
-     free $ptr;
-   }
- );
- my $ptr = strdup "Hello Perl";
- my $scalar;
- window $scalar, $ptr, 10;
- cast $scalar, $free_when_out_of_scope;
- undef $ptr;  # don't need to track the pointer anymore.
- # we can now use scalar as a regular read-only Perl variable
- print $scalar, "\n";  # prints "Hello Perl" without the \0
- # this will free the C pointer
- undef $scalar;
-I<Hint>: Returning a scalar string from a Perl function actually
-copies the value.  If you want to return a string without copying
-then you need to return a reference.
- sub c_string
- {
-   my $ptr = strdup "Hello Perl";
-   my $scalar;
-   window $scalar, $ptr, 10;
-   cast $scalar, $free_when_out_of_scope;
-   \$scalar;
- }
- my $ref = c_string();
- print $$ref, "\n";  # prints "Hello Perl" without the \0
-Not exported by default, but may be exported on request.
-=head1 SEE ALSO
-=over 4
-=item L<FFI::Platypus>
-Main Platypus documentation.
-=back
-=head1 AUTHOR
-Author: Graham Ollis E<lt>plicease@cpan.orgE<gt>
-Contributors:
-Bakkiaraj Murugesan (bakkiaraj)
-Dylan Cali (calid)
-pipcet
-Zaki Mughal (zmughal)
-Fitz Elliott (felliott)
-Vickenty Fesunov (vyf)
-Gregor Herrmann (gregoa)
-Shlomi Fish (shlomif)
-Damyan Ivanov
-Ilya Pavlov (Ilya33)
-Petr Písař (ppisar)
-Mohammad S Anwar (MANWAR)
-Håkon Hægland (hakonhagland, HAKONH)
-Meredith (merrilymeredith, MHOWARD)
-Diab Jerius (DJERIUS)
-Eric Brine (IKEGAMI)
-szTheory
-José Joaquín Atria (JJATRIA)
-Pete Houston (openstrike, HOUSTON)
-Lukas Mai (MAUKE)
-=head1 COPYRIGHT AND LICENSE
-This software is copyright (c) 2015-2022 by Graham Ollis.
-This is free software; you can redistribute it and/or modify it under
-the same terms as the Perl 5 programming language system itself.
-=cut