postfinancecheckout-ruby-sdk 4.5.0 → 5.2.0

data/vendor/bundle/ruby/3.3.0/gems/ffi-1.16.3/lib/ffi/autopointer.rb

@@ -1,188 +0,0 @@
-#
-# Copyright (C) 2008-2010 Wayne Meissner
-# Copyright (C) 2008 Mike Dalessio
-#
-# This file is part of ruby-ffi.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the Ruby FFI project nor the names of its contributors
-#   may be used to endorse or promote products derived from this software
-#   without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-module FFI
-  class AutoPointer < Pointer
-    extend DataConverter
-
-    # @overload initialize(pointer, method)
-    #   @param pointer [Pointer]
-    #   @param method [Method]
-    #   @return [self]
-    #   The passed Method will be invoked at GC time.
-    # @overload initialize(pointer, proc)
-    #   @param pointer [Pointer]
-    #   @return [self]
-    #   The passed Proc will be invoked at GC time (SEE WARNING BELOW!)
-    #   @note WARNING: passing a proc _may_ cause your pointer to never be
-    #     GC'd, unless you're careful to avoid trapping a reference to the
-    #     pointer in the proc. See the test specs for examples.
-    # @overload initialize(pointer) { |p| ... }
-    #   @param pointer [Pointer]
-    #   @yieldparam [Pointer] p +pointer+ passed to the block
-    #   @return [self]
-    #   The passed block will be invoked at GC time.
-    #   @note
-    #     WARNING: passing a block will cause your pointer to never be GC'd.
-    #     This is bad.
-    # @overload initialize(pointer)
-    #   @param pointer [Pointer]
-    #   @return [self]
-    #   The pointer's release() class method will be invoked at GC time.
-    #
-    # @note The safest, and therefore preferred, calling
-    #  idiom is to pass a Method as the second parameter. Example usage:
-    #
-    #   class PointerHelper
-    #     def self.release(pointer)
-    #       ...
-    #     end
-    #   end
-    #
-    #   p = AutoPointer.new(other_pointer, PointerHelper.method(:release))
-    #
-    #  The above code will cause PointerHelper#release to be invoked at GC time.
-    #
-    # @note
-    #  The last calling idiom (only one parameter) is generally only
-    #  going to be useful if you subclass {AutoPointer}, and override
-    #  #release, which by default does nothing.
-    def initialize(ptr, proc=nil, &block)
-      raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) ||
-          ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
-      super(ptr.type_size, ptr)
-
-      @releaser = if proc
-                    if not proc.respond_to?(:call)
-                      raise RuntimeError.new("proc must be callable")
-                    end
-                    Releaser.new(ptr, proc)
-
-                  else
-                    if not self.class.respond_to?(:release, true)
-                      raise RuntimeError.new("no release method defined")
-                    end
-                    Releaser.new(ptr, self.class.method(:release))
-                  end
-
-      ObjectSpace.define_finalizer(self, @releaser)
-      self
-    end
-
-    # @return [nil]
-    # Free the pointer.
-    def free
-      @releaser.free
-    end
-
-    # @param [Boolean] autorelease
-    # @return [Boolean] +autorelease+
-    # Set +autorelease+ property. See {Pointer Autorelease section at Pointer}.
-    def autorelease=(autorelease)
-      raise FrozenError.new("can't modify frozen #{self.class}") if frozen?
-      @releaser.autorelease=(autorelease)
-    end
-
-    # @return [Boolean] +autorelease+
-    # Get +autorelease+ property. See {Pointer Autorelease section at Pointer}.
-    def autorelease?
-      @releaser.autorelease
-    end
-
-    # @abstract Base class for {AutoPointer}'s releasers.
-    #
-    #  All subclasses of Releaser should define a +#release(ptr)+ method.
-    # A releaser is an object in charge of release an {AutoPointer}.
-    class Releaser
-      attr_accessor :autorelease
-
-      # @param [Pointer] ptr
-      # @param [#call] proc
-      # @return [nil]
-      # A new instance of Releaser.
-      def initialize(ptr, proc)
-        @ptr = ptr
-        @proc = proc
-        @autorelease = true
-      end
-
-      # @return [nil]
-      # Free pointer.
-      def free
-        if @ptr
-          release(@ptr)
-          @autorelease = false
-          @ptr = nil
-          @proc = nil
-        end
-      end
-
-      # @param args
-      # Release pointer if +autorelease+ is set.
-      def call(*args)
-        release(@ptr) if @autorelease && @ptr
-      end
-
-      # Release +ptr+ by using Proc or Method defined at +ptr+
-      # {AutoPointer#initialize initialization}.
-      #
-      # @param [Pointer] ptr
-      # @return [nil]
-      def release(ptr)
-        @proc.call(ptr)
-      end
-    end
-
-    # Return native type of AutoPointer.
-    #
-    # Override {DataConverter#native_type}.
-    # @return [Type::POINTER]
-    # @raise {RuntimeError} if class does not implement a +#release+ method
-    def self.native_type
-      if not self.respond_to?(:release, true)
-        raise RuntimeError.new("no release method defined for #{self.inspect}")
-      end
-      Type::POINTER
-    end
-
-    # Create a new AutoPointer.
-    #
-    # Override {DataConverter#from_native}.
-    # @overload self.from_native(ptr, ctx)
-    #   @param [Pointer] ptr
-    #   @param ctx not used. Please set +nil+.
-    # @return [AutoPointer]
-    def self.from_native(val, ctx)
-      self.new(val)
-    end
-  end
-
-end

data/vendor/bundle/ruby/3.3.0/gems/ffi-1.16.3/lib/ffi/dynamic_library.rb

@@ -1,89 +0,0 @@
-#
-# Copyright (C) 2008-2010 Wayne Meissner
-#
-# This file is part of ruby-ffi.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the Ruby FFI project nor the names of its contributors
-#   may be used to endorse or promote products derived from this software
-#   without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#
-
-module FFI
-  class DynamicLibrary
-    SEARCH_PATH = %w[/usr/lib /usr/local/lib /opt/local/lib]
-    if FFI::Platform::ARCH == 'aarch64' && FFI::Platform.mac?
-      SEARCH_PATH << '/opt/homebrew/lib'
-    end
-
-    SEARCH_PATH_MESSAGE = "Searched in <system library path>, #{SEARCH_PATH.join(', ')}".freeze
-
-    def self.load_library(name, flags)
-      if name == FFI::CURRENT_PROCESS
-        FFI::DynamicLibrary.open(nil, RTLD_LAZY | RTLD_LOCAL)
-      else
-        flags ||= RTLD_LAZY | RTLD_LOCAL
-
-        libnames = (name.is_a?(::Array) ? name : [name])
-        libnames = libnames.map(&:to_s).map { |n| [n, FFI.map_library_name(n)].uniq }.flatten.compact
-        errors = []
-
-        libnames.each do |libname|
-          lib = try_load(libname, flags, errors)
-          return lib if lib
-
-          unless libname.start_with?("/") || FFI::Platform.windows?
-            SEARCH_PATH.each do |prefix|
-              path = "#{prefix}/#{libname}"
-              if File.exist?(path)
-                lib = try_load(path, flags, errors)
-                return lib if lib
-              end
-            end
-          end
-        end
-
-        raise LoadError, [*errors, SEARCH_PATH_MESSAGE].join(".\n")
-      end
-    end
-    private_class_method :load_library
-
-    def self.try_load(libname, flags, errors)
-      begin
-        lib = FFI::DynamicLibrary.open(libname, flags)
-        return lib if lib
-
-      # LoadError for C ext & JRuby, RuntimeError for TruffleRuby
-      rescue LoadError, RuntimeError => ex
-        if ex.message =~ /(([^ \t()])+\.so([^ \t:()])*):([ \t])*(invalid ELF header|file too short|invalid file format)/
-          if File.binread($1) =~ /(?:GROUP|INPUT) *\( *([^ \)]+)/
-            return try_load($1, flags, errors)
-          end
-        end
-
-        errors << ex
-        nil
-      end
-    end
-    private_class_method :try_load
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ffi-1.16.3/lib/ffi/enum.rb

@@ -1,303 +0,0 @@
-#
-# Copyright (C) 2009, 2010 Wayne Meissner
-# Copyright (C) 2009 Luc Heinrich
-#
-# This file is part of ruby-ffi.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the Ruby FFI project nor the names of its contributors
-#   may be used to endorse or promote products derived from this software
-#   without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-
-module FFI
-
-  # An instance of this class permits to manage {Enum}s. In fact, Enums is a collection of {Enum}s.
-  class Enums
-
-    # @return [nil]
-    def initialize
-      @all_enums = Array.new
-      @tagged_enums = Hash.new
-      @symbol_map = Hash.new
-    end
-
-    # @param [Enum] enum
-    # Add an {Enum} to the collection.
-    def <<(enum)
-      @all_enums << enum
-      @tagged_enums[enum.tag] = enum unless enum.tag.nil?
-      @symbol_map.merge!(enum.symbol_map)
-    end
-
-    # @param query enum tag or part of an enum name
-    # @return [Enum]
-    # Find a {Enum} in collection.
-    def find(query)
-      if @tagged_enums.has_key?(query)
-        @tagged_enums[query]
-      else
-        @all_enums.detect { |enum| enum.symbols.include?(query) }
-      end
-    end
-
-    # @param symbol a symbol to find in merge symbol maps of all enums.
-    # @return a symbol
-    def __map_symbol(symbol)
-      @symbol_map[symbol]
-    end
-
-  end
-
-  # Represents a C enum.
-  #
-  # For a C enum:
-  #  enum fruits {
-  #    apple,
-  #    banana,
-  #    orange,
-  #    pineapple
-  #  };
-  # are defined this vocabulary:
-  # * a _symbol_ is a word from the enumeration (ie. _apple_, by example);
-  # * a _value_ is the value of a symbol in the enumeration (by example, apple has value _0_ and banana _1_).
-  class Enum
-    include DataConverter
-
-    attr_reader :tag
-    attr_reader :native_type
-
-    # @overload initialize(info, tag=nil)
-    #   @param [nil, Enumerable] info
-    #   @param [nil, Symbol] tag enum tag
-    # @overload initialize(native_type, info, tag=nil)
-    #   @param [FFI::Type] native_type Native type for new Enum
-    #   @param [nil, Enumerable] info symbols and values for new Enum
-    #   @param [nil, Symbol] tag name of new Enum
-    def initialize(*args)
-      @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
-      info, @tag = *args
-      @kv_map = Hash.new
-      unless info.nil?
-        last_cst = nil
-        value = 0
-        info.each do |i|
-          case i
-          when Symbol
-            raise ArgumentError, "duplicate enum key" if @kv_map.has_key?(i)
-            @kv_map[i] = value
-            last_cst = i
-            value += 1
-          when Integer
-            @kv_map[last_cst] = i
-            value = i+1
-          end
-        end
-      end
-      @vk_map = @kv_map.invert
-    end
-
-    # @return [Array] enum symbol names
-    def symbols
-      @kv_map.keys
-    end
-
-    # Get a symbol or a value from the enum.
-    # @overload [](query)
-    #  Get enum value from symbol.
-    #  @param [Symbol] query
-    #  @return [Integer]
-    # @overload [](query)
-    #  Get enum symbol from value.
-    #  @param [Integer] query
-    #  @return [Symbol]
-    def [](query)
-      case query
-      when Symbol
-        @kv_map[query]
-      when Integer
-        @vk_map[query]
-      end
-    end
-    alias find []
-
-    # Get the symbol map.
-    # @return [Hash]
-    def symbol_map
-      @kv_map
-    end
-
-    alias to_h symbol_map
-    alias to_hash symbol_map
-
-    # @param [Symbol, Integer, #to_int] val
-    # @param ctx unused
-    # @return [Integer] value of a enum symbol
-    def to_native(val, ctx)
-      @kv_map[val] || if val.is_a?(Integer)
-        val
-      elsif val.respond_to?(:to_int)
-        val.to_int
-      else
-        raise ArgumentError, "invalid enum value, #{val.inspect}"
-      end
-    end
-
-    # @param val
-    # @return symbol name if it exists for +val+.
-    def from_native(val, ctx)
-      @vk_map[val] || val
-    end
-  end
-
-  # Represents a C enum whose values are power of 2
-  #
-  # @example
-  #  enum {
-  #    red = (1<<0),
-  #    green = (1<<1),
-  #    blue = (1<<2)
-  #  }
-  #
-  # Contrary to classical enums, bitmask values are usually combined
-  # when used.
-  class Bitmask < Enum
-
-    # @overload initialize(info, tag=nil)
-    #   @param [nil, Enumerable] info symbols and bit rank for new Bitmask
-    #   @param [nil, Symbol] tag name of new Bitmask
-    # @overload initialize(native_type, info, tag=nil)
-    #   @param [FFI::Type] native_type Native type for new Bitmask
-    #   @param [nil, Enumerable] info symbols and bit rank for new Bitmask
-    #   @param [nil, Symbol] tag name of new Bitmask
-    def initialize(*args)
-      @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
-      @signed = [Type::INT8, Type::INT16, Type::INT32, Type::INT64].include?(@native_type)
-      info, @tag = *args
-      @kv_map = Hash.new
-      unless info.nil?
-        last_cst = nil
-        value = 0
-        info.each do |i|
-          case i
-          when Symbol
-            raise ArgumentError, "duplicate bitmask key" if @kv_map.has_key?(i)
-            @kv_map[i] = 1 << value
-            last_cst = i
-            value += 1
-          when Integer
-            raise ArgumentError, "bitmask index should be positive" if i<0
-            @kv_map[last_cst] = 1 << i
-            value = i+1
-          end
-        end
-      end
-      @vk_map = @kv_map.invert
-    end
-
-    # Get a symbol list or a value from the bitmask
-    # @overload [](*query)
-    #  Get bitmask value from symbol list
-    #  @param [Symbol] query
-    #  @return [Integer]
-    # @overload [](query)
-    #  Get bitmask value from symbol array
-    #  @param [Array<Symbol>] query
-    #  @return [Integer]
-    # @overload [](*query)
-    #  Get a list of bitmask symbols corresponding to
-    #  the or reduction of a list of integer
-    #  @param [Integer] query
-    #  @return [Array<Symbol>]
-    # @overload [](query)
-    #  Get a list of bitmask symbols corresponding to
-    #  the or reduction of a list of integer
-    #  @param [Array<Integer>] query
-    #  @return [Array<Symbol>]
-    def [](*query)
-      flat_query = query.flatten
-      raise ArgumentError, "query should be homogeneous, #{query.inspect}" unless flat_query.all? { |o| o.is_a?(Symbol) } || flat_query.all? { |o| o.is_a?(Integer) || o.respond_to?(:to_int) }
-      case flat_query[0]
-      when Symbol
-        flat_query.inject(0) do |val, o|
-          v = @kv_map[o]
-          if v then val | v else val end
-        end
-      when Integer, ->(o) { o.respond_to?(:to_int) }
-        val = flat_query.inject(0) { |mask, o| mask |= o.to_int }
-        @kv_map.select { |_, v| v & val != 0 }.keys
-      end
-    end
-
-    # Get the native value of a bitmask
-    # @overload to_native(query, ctx)
-    #  @param [Symbol, Integer, #to_int] query
-    #  @param ctx unused
-    #  @return [Integer] value of a bitmask
-    # @overload to_native(query, ctx)
-    #  @param [Array<Symbol, Integer, #to_int>] query
-    #  @param ctx unused
-    #  @return [Integer] value of a bitmask
-    def to_native(query, ctx)
-      return 0 if query.nil?
-      flat_query = [query].flatten
-      res = flat_query.inject(0) do |val, o|
-        case o
-        when Symbol
-          v = @kv_map[o]
-          raise ArgumentError, "invalid bitmask value, #{o.inspect}" unless v
-          val | v
-        when Integer
-          val | o
-        when ->(obj) { obj.respond_to?(:to_int) }
-          val | o.to_int
-        else
-          raise ArgumentError, "invalid bitmask value, #{o.inspect}"
-        end
-      end
-      # Take two's complement of positive values bigger than the max value
-      # for the type when native type is signed.
-      if @signed && res >= (1 << (@native_type.size * 8 - 1))
-        res = -(-res & ((1 << (@native_type.size * 8)) - 1))
-      end
-      res
-    end
-
-    # @param [Integer] val
-    # @param ctx unused
-    # @return [Array<Symbol, Integer>] list of symbol names corresponding to val, plus an optional remainder if some bits don't match any constant
-    def from_native(val, ctx)
-      flags = @kv_map.select { |_, v| v & val != 0 }
-      list = flags.keys
-      # force an unsigned value of the correct size
-      val &= (1 << (@native_type.size * 8)) - 1 if @signed
-      # If there are unmatch flags,
-      # return them in an integer,
-      # else information can be lost.
-      # Similar to Enum behavior.
-      remainder = val ^ flags.values.reduce(0, :|)
-      list.push remainder unless remainder == 0
-      return list
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ffi-1.16.3/lib/ffi/ffi.rb

@@ -1,50 +0,0 @@
-#
-# Copyright (C) 2008-2010 JRuby project
-#
-# This file is part of ruby-ffi.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the Ruby FFI project nor the names of its contributors
-#   may be used to endorse or promote products derived from this software
-#   without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-require 'ffi/compat'
-require 'ffi/platform'
-require 'ffi/data_converter'
-require 'ffi/types'
-require 'ffi/library_path'
-require 'ffi/library'
-require 'ffi/errno'
-require 'ffi/abstract_memory'
-require 'ffi/pointer'
-require 'ffi/memorypointer'
-require 'ffi/struct'
-require 'ffi/union'
-require 'ffi/managedstruct'
-require 'ffi/callback'
-require 'ffi/io'
-require 'ffi/autopointer'
-require 'ffi/variadic'
-require 'ffi/enum'
-require 'ffi/version'
-require 'ffi/function'

data/vendor/bundle/ruby/3.3.0/gems/ffi-1.16.3/lib/ffi/function.rb

@@ -1,71 +0,0 @@
-#
-# Copyright (C) 2008-2010 JRuby project
-#
-# This file is part of ruby-ffi.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the Ruby FFI project nor the names of its contributors
-#   may be used to endorse or promote products derived from this software
-#   without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-module FFI
-  class Function
-    # Only MRI allows function type queries
-    if private_method_defined?(:type)
-      # Retrieve the return type of the function
-      #
-      # This method returns FFI type returned by the function.
-      #
-      # @return [FFI::Type]
-      def return_type
-        type.return_type
-      end
-
-      # Retrieve Array of parameter types
-      #
-      # This method returns an Array of FFI types accepted as function parameters.
-      #
-      # @return [Array<FFI::Type>]
-      def param_types
-        type.param_types
-      end
-    end
-
-    # Stash the Function in a module variable so it can be inspected by attached_functions.
-    # On CRuby it also ensures that it does not get garbage collected.
-    module RegisterAttach
-      def attach(mod, name)
-        funcs = mod.instance_variable_get("@ffi_functions")
-        unless funcs
-          funcs = {}
-          mod.instance_variable_set("@ffi_functions", funcs)
-        end
-        funcs[name.to_sym] = self
-        # Jump to the native attach method of CRuby, JRuby or Tuffleruby
-        super
-      end
-    end
-    private_constant :RegisterAttach
-    prepend RegisterAttach
-  end
-end