nova_ta 0.1.2-x64-mingw-ucrt

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d50f81fb271f3ed8f77a77b4e7ddb02e48d5c416acb13df00617019769f85f7a
+  data.tar.gz: 788afdcf1ac99aa5ce38dbebcb5316cb7924cf60113dae0f5b43ce8af3809080
+SHA512:
+  metadata.gz: 624a1cf5c6f394b7bc1ea839ee3c0626c6a7e231b90a788be87c742a5737452267f741e463569f4f13f2f20636add3f5d43b676e9d750db923ea62034ab70365
+  data.tar.gz: ad5f4444a19763d77053d684ab1f68177917cbc058f8dc1d788717223604673449e35a2999d3a80abba85d3867e406b1b5d5098a6efac1c99c8af1b8e0ca7034

data/lib/nova_ta.rb

@@ -0,0 +1,1374 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .rb file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the details of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Ruby
+# helpers directly inline like we're doing here.
+
+require 'ffi'
+
+
+module NovaTa
+  def self.uniffi_in_range(i, type_name, min, max)
+  raise TypeError, "no implicit conversion of #{i} into Integer" unless i.respond_to?(:to_int)
+  i = i.to_int
+  raise RangeError, "#{type_name} requires #{min} <= value < #{max}" unless (min <= i && i < max)
+  i
+end
+
+def self.uniffi_utf8(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v = v.to_str.encode(Encoding::UTF_8)
+  raise Encoding::InvalidByteSequenceError, "not a valid UTF-8 encoded string" unless v.valid_encoding?
+  v
+end
+
+def self.uniffi_bytes(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v.to_str
+end
+
+  class RustBuffer < FFI::Struct
+  layout :capacity, :uint64,
+         :len,      :uint64,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return NovaTa.rust_call(:ffi_nova_ta_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return NovaTa.rust_call(:ffi_nova_ta_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    NovaTa.rust_call(:ffi_nova_ta_rustbuffer_free, self)
+  end
+
+  def capacity
+    self[:capacity]
+  end
+
+  def len
+    self[:len]
+  end
+
+  def len=(value)
+    self[:len] = value
+  end
+
+  def data
+    self[:data]
+  end
+
+  def to_s
+    "RustBuffer(capacity=#{capacity}, len=#{len}, data=#{data.read_bytes len})"
+  end
+
+  # The allocated buffer will be automatically freed if an error occurs, ensuring that
+  # we don't accidentally leak it.
+  def self.allocWithBuilder
+    builder = RustBufferBuilder.new
+
+    begin
+      yield builder
+    rescue => e
+      builder.discard
+      raise e
+    end
+  end
+
+  # The RustBuffer will be freed once the context-manager exits, ensuring that we don't
+  # leak it even if an error occurs.
+  def consumeWithStream
+    stream = RustBufferStream.new self
+
+    yield stream
+
+    raise RuntimeError, 'junk data left in buffer after consuming' if stream.remaining != 0
+  ensure
+    free
+  end# The primitive String type.
+
+  def self.allocFromString(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write value.encode('utf-8')
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoString
+    consumeWithStream do |stream|
+      return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  
+
+  
+end
+
+module UniFFILib
+  class ForeignBytes < FFI::Struct
+    layout :len,      :int32,
+           :data,     :pointer
+
+    def len
+      self[:len]
+    end
+
+    def data
+      self[:data]
+    end
+
+    def to_s
+      "ForeignBytes(len=#{len}, data=#{data.read_bytes(len)})"
+    end
+  end
+end
+
+private_constant :UniFFILib
+  
+# Helper for structured reading of values from a RustBuffer.
+class RustBufferStream
+
+  def initialize(rbuf)
+    @rbuf = rbuf
+    @offset = 0
+  end
+
+  def remaining
+    @rbuf.len - @offset
+  end
+
+  def read(size)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    data = @rbuf.data.get_bytes @offset, size
+
+    @offset += size
+
+    data
+  end
+
+  def readU32
+    unpack_from 4, 'L>'
+  end
+
+  def readU64
+    unpack_from 8, 'Q>'
+  end
+
+  def readF64
+    unpack_from 8, 'G'
+  end
+
+  def readBool
+    v = unpack_from 1, 'c'
+
+    return false if v == 0
+    return true if v == 1
+
+    raise InternalError, 'Unexpected byte for Boolean type'
+  end
+
+  def readString
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative string length' if size.negative?
+
+    read(size).force_encoding(Encoding::UTF_8)
+  end
+
+  # The Object type Alma.
+
+  def readTypeAlma
+    handle = unpack_from 8, 'Q>'
+    return Alma.uniffi_allocate(handle)
+  end
+
+  # The Object type Cti.
+
+  def readTypeCti
+    handle = unpack_from 8, 'Q>'
+    return Cti.uniffi_allocate(handle)
+  end
+
+  # The Object type Gaussian.
+
+  def readTypeGaussian
+    handle = unpack_from 8, 'Q>'
+    return Gaussian.uniffi_allocate(handle)
+  end
+
+  # The Object type Kama.
+
+  def readTypeKama
+    handle = unpack_from 8, 'Q>'
+    return Kama.uniffi_allocate(handle)
+  end
+
+  # The Object type Ker.
+
+  def readTypeKer
+    handle = unpack_from 8, 'Q>'
+    return Ker.uniffi_allocate(handle)
+  end
+
+  # The Object type LinearWma.
+
+  def readTypeLinearWma
+    handle = unpack_from 8, 'Q>'
+    return LinearWma.uniffi_allocate(handle)
+  end
+
+  # The Object type Lsma.
+
+  def readTypeLsma
+    handle = unpack_from 8, 'Q>'
+    return Lsma.uniffi_allocate(handle)
+  end
+
+  # The Object type UltimateSmoother.
+
+  def readTypeUltimateSmoother
+    handle = unpack_from 8, 'Q>'
+    return UltimateSmoother.uniffi_allocate(handle)
+  end
+
+  
+
+  
+
+  # The Error type NovaError
+
+  def readTypeNovaError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return NovaError::Never.new(
+        readString()
+      )
+    end
+    if variant == 2
+      return NovaError::InvalidPeriod.new(
+        readString()
+      )
+    end
+    if variant == 3
+      return NovaError::InvalidInput.new(
+        readString()
+      )
+    end
+    if variant == 4
+      return NovaError::WindowIdx.new(
+        readString()
+      )
+    end
+    if variant == 5
+      return NovaError::Number.new(
+        readString()
+      )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeNovaError'
+  end
+  
+
+  
+
+  def unpack_from(size, format)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    value = @rbuf.data.get_bytes(@offset, size).unpack format
+
+    @offset += size
+
+    # TODO: verify this
+    raise 'more than one element!!!' if value.size > 1
+
+    value[0]
+  end
+end
+
+private_constant :RustBufferStream
+  
+# Helper for structured writing of values into a RustBuffer.
+class RustBufferBuilder
+  def initialize
+    @rust_buf = RustBuffer.alloc 16
+    @rust_buf.len = 0
+  end
+
+  def finalize
+    rbuf = @rust_buf
+
+    @rust_buf = nil
+
+    rbuf
+  end
+
+  def discard
+    return if @rust_buf.nil?
+
+    rbuf = finalize
+    rbuf.free
+  end
+
+  def write(value)
+    reserve(value.bytes.size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, value.bytes
+    end
+  end
+
+  def write_U32(v)
+    v = NovaTa::uniffi_in_range(v, "u32", 0, 2**32)
+    pack_into(4, 'L>', v)
+  end
+
+  def write_U64(v)
+    v = NovaTa::uniffi_in_range(v, "u64", 0, 2**64)
+    pack_into(8, 'Q>', v)
+  end
+
+  def write_F64(v)
+    pack_into(8, 'G', v)
+  end
+
+  def write_Bool(v)
+    pack_into(1, 'c', v ? 1 : 0)
+  end
+
+  def write_String(v)
+    v = NovaTa::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Object type Alma.
+
+  def write_TypeAlma(obj)
+    handle = Alma.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type Cti.
+
+  def write_TypeCti(obj)
+    handle = Cti.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type Gaussian.
+
+  def write_TypeGaussian(obj)
+    handle = Gaussian.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type Kama.
+
+  def write_TypeKama(obj)
+    handle = Kama.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type Ker.
+
+  def write_TypeKer(obj)
+    handle = Ker.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type LinearWma.
+
+  def write_TypeLinearWma(obj)
+    handle = LinearWma.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type Lsma.
+
+  def write_TypeLsma(obj)
+    handle = Lsma.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type UltimateSmoother.
+
+  def write_TypeUltimateSmoother(obj)
+    handle = UltimateSmoother.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  
+
+  
+
+  private
+
+  def reserve(num_bytes)
+    if @rust_buf.len + num_bytes > @rust_buf.capacity
+      @rust_buf = RustBuffer.reserve(@rust_buf, num_bytes)
+    end
+
+    yield
+
+    @rust_buf.len += num_bytes
+  end
+
+  def pack_into(size, format, value)
+    reserve(size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, [value].pack(format).bytes
+    end
+  end
+end
+
+private_constant :RustBufferBuilder
+
+  # Error definitions
+  class RustCallStatus < FFI::Struct
+  layout :code,    :int8,
+         :error_buf, RustBuffer
+
+  def code
+    self[:code]
+  end
+
+  def error_buf
+    self[:error_buf]
+  end
+
+  def to_s
+    "RustCallStatus(code=#{self[:code]})"
+  end
+end
+
+# These match the values from the uniffi::rustcalls module
+CALL_SUCCESS = 0
+CALL_ERROR = 1
+CALL_PANIC = 2
+
+
+class NovaError
+    Never = Class.new StandardError
+    InvalidPeriod = Class.new StandardError
+    InvalidInput = Class.new StandardError
+    WindowIdx = Class.new StandardError
+    Number = Class.new StandardError
+
+end
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+
+  NovaError => :readTypeNovaError,
+
+}
+
+private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CALL_PANIC,
+                 :RustCallStatus
+
+def self.consume_buffer_into_error(error_module, rust_buffer)
+  rust_buffer.consumeWithStream do |stream|
+    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module]
+    return stream.send(reader_method)
+  end
+end
+
+class InternalError < StandardError
+end
+
+def self.rust_call(fn_name, *args)
+  # Call a rust function
+  rust_call_with_error(nil, fn_name, *args)
+end
+
+def self.rust_call_with_error(error_module, fn_name, *args)
+  # Call a rust function and handle errors
+  #
+  # Use this when the rust function returns a Result<>.  error_module must be the error_module that corresponds to that Result.
+
+
+  # Note: RustCallStatus.new zeroes out the struct, which is exactly what we
+  # want to pass to Rust (code=0, error_buf=RustBuffer(len=0, capacity=0,
+  # data=NULL))
+  status = RustCallStatus.new
+  args << status
+
+  result = UniFFILib.public_send(fn_name, *args)
+
+  case status.code
+  when CALL_SUCCESS
+    result
+  when CALL_ERROR
+    if error_module.nil?
+      status.error_buf.free
+      raise InternalError, "CALL_ERROR with no error_module set"
+    else
+      raise consume_buffer_into_error(error_module, status.error_buf)
+    end
+  when CALL_PANIC
+    # When the rust code sees a panic, it tries to construct a RustBuffer
+    # with the message.  But if that code panics, then it just sends back
+    # an empty buffer.
+    if status.error_buf.len > 0
+      raise InternalError, status.error_buf.consumeIntoString()
+    else
+      raise InternalError, "Rust panic"
+    end
+  else
+    raise InternalError, "Unknown call status: #{status.code}"
+  end
+end
+
+private_class_method :consume_buffer_into_error
+
+  # This is how we find and load the dynamic library provided by the component.
+# For now we just look it up by name.
+module UniFFILib
+  extend FFI::Library
+
+  
+  ffi_lib 'nova_ta'
+  
+
+  attach_function :uniffi_nova_ta_fn_clone_alma,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_free_alma,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_constructor_alma_new,
+    [:uint64, :double, :uint32, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_method_alma_ready,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_nova_ta_fn_method_alma_reset,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_method_alma_update,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :double
+  attach_function :uniffi_nova_ta_fn_clone_gaussian,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_free_gaussian,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_constructor_gaussian_new,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_method_gaussian_ready,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_nova_ta_fn_method_gaussian_reset,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_method_gaussian_update,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :double
+  attach_function :uniffi_nova_ta_fn_clone_kama,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_free_kama,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_constructor_kama_new,
+    [:uint64, :uint64, :uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_method_kama_ready,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_nova_ta_fn_method_kama_reset,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_method_kama_update,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :double
+  attach_function :uniffi_nova_ta_fn_clone_lsma,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_free_lsma,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_constructor_lsma_new,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_method_lsma_ready,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_nova_ta_fn_method_lsma_reset,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_method_lsma_update,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :double
+  attach_function :uniffi_nova_ta_fn_clone_ultimatesmoother,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_free_ultimatesmoother,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_constructor_ultimatesmoother_new,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_method_ultimatesmoother_ready,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_nova_ta_fn_method_ultimatesmoother_reset,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_method_ultimatesmoother_update,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :double
+  attach_function :uniffi_nova_ta_fn_clone_linearwma,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_free_linearwma,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_constructor_linearwma_new,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_method_linearwma_ready,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_nova_ta_fn_method_linearwma_reset,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_method_linearwma_update,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :double
+  attach_function :uniffi_nova_ta_fn_clone_cti,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_free_cti,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_constructor_cti_new,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_method_cti_ready,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_nova_ta_fn_method_cti_reset,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_method_cti_update,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :double
+  attach_function :uniffi_nova_ta_fn_clone_ker,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_free_ker,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_constructor_ker_new,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_nova_ta_fn_method_ker_ready,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  attach_function :uniffi_nova_ta_fn_method_ker_reset,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_nova_ta_fn_method_ker_update,
+    [:uint64, :double, RustCallStatus.by_ref],
+    :double
+  attach_function :ffi_nova_ta_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_nova_ta_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_nova_ta_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :ffi_nova_ta_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_nova_ta_checksum_method_alma_ready,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_alma_reset,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_alma_update,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_gaussian_ready,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_gaussian_reset,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_gaussian_update,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_kama_ready,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_kama_reset,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_kama_update,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_lsma_ready,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_lsma_reset,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_lsma_update,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_ultimatesmoother_ready,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_ultimatesmoother_reset,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_ultimatesmoother_update,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_linearwma_ready,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_linearwma_reset,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_linearwma_update,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_cti_ready,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_cti_reset,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_cti_update,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_ker_ready,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_ker_reset,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_method_ker_update,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_constructor_alma_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_constructor_gaussian_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_constructor_kama_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_constructor_lsma_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_constructor_ultimatesmoother_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_constructor_linearwma_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_constructor_cti_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_nova_ta_checksum_constructor_ker_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :ffi_nova_ta_uniffi_contract_version,
+    [RustCallStatus.by_ref],
+    :uint32
+  
+end
+
+  # Public interface members begin here.
+
+  
+  
+
+  
+
+  
+  class Alma
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      NovaTa.rust_call(
+        :uniffi_nova_ta_fn_free_alma,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a Alma instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return NovaTa.rust_call(
+      :uniffi_nova_ta_fn_clone_alma,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(period, offset, sigma)
+        period = NovaTa::uniffi_in_range(period, "u64", 0, 2**64)
+        
+        offset = offset
+        
+        sigma = NovaTa::uniffi_in_range(sigma, "u32", 0, 2**32)
+        
+    handle = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_constructor_alma_new,period,offset,sigma)
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def ready()
+    result = NovaTa.rust_call(:uniffi_nova_ta_fn_method_alma_ready,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def reset()
+      NovaTa.rust_call(:uniffi_nova_ta_fn_method_alma_reset,uniffi_clone_handle(),)
+  end
+  
+  def update(input)
+        input = input
+        
+    result = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_method_alma_update,uniffi_clone_handle(),input)
+    return result.to_f
+  end
+  
+end
+  
+  class Gaussian
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      NovaTa.rust_call(
+        :uniffi_nova_ta_fn_free_gaussian,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a Gaussian instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return NovaTa.rust_call(
+      :uniffi_nova_ta_fn_clone_gaussian,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(period, sigma)
+        period = NovaTa::uniffi_in_range(period, "u64", 0, 2**64)
+        
+        sigma = sigma
+        
+    handle = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_constructor_gaussian_new,period,sigma)
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def ready()
+    result = NovaTa.rust_call(:uniffi_nova_ta_fn_method_gaussian_ready,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def reset()
+      NovaTa.rust_call(:uniffi_nova_ta_fn_method_gaussian_reset,uniffi_clone_handle(),)
+  end
+  
+  def update(input)
+        input = input
+        
+    result = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_method_gaussian_update,uniffi_clone_handle(),input)
+    return result.to_f
+  end
+  
+end
+  
+  class Kama
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      NovaTa.rust_call(
+        :uniffi_nova_ta_fn_free_kama,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a Kama instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return NovaTa.rust_call(
+      :uniffi_nova_ta_fn_clone_kama,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(fast, slow, ker)
+        fast = NovaTa::uniffi_in_range(fast, "u64", 0, 2**64)
+        
+        slow = NovaTa::uniffi_in_range(slow, "u64", 0, 2**64)
+        
+        ker = NovaTa::uniffi_in_range(ker, "u64", 0, 2**64)
+        
+    handle = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_constructor_kama_new,fast,slow,ker)
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def ready()
+    result = NovaTa.rust_call(:uniffi_nova_ta_fn_method_kama_ready,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def reset()
+      NovaTa.rust_call(:uniffi_nova_ta_fn_method_kama_reset,uniffi_clone_handle(),)
+  end
+  
+  def update(input)
+        input = input
+        
+    result = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_method_kama_update,uniffi_clone_handle(),input)
+    return result.to_f
+  end
+  
+end
+  
+  class Lsma
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      NovaTa.rust_call(
+        :uniffi_nova_ta_fn_free_lsma,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a Lsma instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return NovaTa.rust_call(
+      :uniffi_nova_ta_fn_clone_lsma,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(period)
+        period = NovaTa::uniffi_in_range(period, "u64", 0, 2**64)
+        
+    handle = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_constructor_lsma_new,period)
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def ready()
+    result = NovaTa.rust_call(:uniffi_nova_ta_fn_method_lsma_ready,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def reset()
+      NovaTa.rust_call(:uniffi_nova_ta_fn_method_lsma_reset,uniffi_clone_handle(),)
+  end
+  
+  def update(input)
+        input = input
+        
+    result = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_method_lsma_update,uniffi_clone_handle(),input)
+    return result.to_f
+  end
+  
+end
+  
+  class UltimateSmoother
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      NovaTa.rust_call(
+        :uniffi_nova_ta_fn_free_ultimatesmoother,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a UltimateSmoother instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return NovaTa.rust_call(
+      :uniffi_nova_ta_fn_clone_ultimatesmoother,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(period)
+        period = NovaTa::uniffi_in_range(period, "u64", 0, 2**64)
+        
+    handle = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_constructor_ultimatesmoother_new,period)
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def ready()
+    result = NovaTa.rust_call(:uniffi_nova_ta_fn_method_ultimatesmoother_ready,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def reset()
+      NovaTa.rust_call(:uniffi_nova_ta_fn_method_ultimatesmoother_reset,uniffi_clone_handle(),)
+  end
+  
+  def update(input)
+        input = input
+        
+    result = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_method_ultimatesmoother_update,uniffi_clone_handle(),input)
+    return result.to_f
+  end
+  
+end
+  
+  class LinearWma
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      NovaTa.rust_call(
+        :uniffi_nova_ta_fn_free_linearwma,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a LinearWma instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return NovaTa.rust_call(
+      :uniffi_nova_ta_fn_clone_linearwma,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(period)
+        period = NovaTa::uniffi_in_range(period, "u64", 0, 2**64)
+        
+    handle = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_constructor_linearwma_new,period)
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def ready()
+    result = NovaTa.rust_call(:uniffi_nova_ta_fn_method_linearwma_ready,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def reset()
+      NovaTa.rust_call(:uniffi_nova_ta_fn_method_linearwma_reset,uniffi_clone_handle(),)
+  end
+  
+  def update(input)
+        input = input
+        
+    result = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_method_linearwma_update,uniffi_clone_handle(),input)
+    return result.to_f
+  end
+  
+end
+  
+  class Cti
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      NovaTa.rust_call(
+        :uniffi_nova_ta_fn_free_cti,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a Cti instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return NovaTa.rust_call(
+      :uniffi_nova_ta_fn_clone_cti,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(period)
+        period = NovaTa::uniffi_in_range(period, "u64", 0, 2**64)
+        
+    handle = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_constructor_cti_new,period)
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def ready()
+    result = NovaTa.rust_call(:uniffi_nova_ta_fn_method_cti_ready,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def reset()
+      NovaTa.rust_call(:uniffi_nova_ta_fn_method_cti_reset,uniffi_clone_handle(),)
+  end
+  
+  def update(input)
+        input = input
+        
+    result = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_method_cti_update,uniffi_clone_handle(),input)
+    return result.to_f
+  end
+  
+end
+  
+  class Ker
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      NovaTa.rust_call(
+        :uniffi_nova_ta_fn_free_ker,
+        handle
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a Ker instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return NovaTa.rust_call(
+      :uniffi_nova_ta_fn_clone_ker,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(period)
+        period = NovaTa::uniffi_in_range(period, "u64", 0, 2**64)
+        
+    handle = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_constructor_ker_new,period)
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def ready()
+    result = NovaTa.rust_call(:uniffi_nova_ta_fn_method_ker_ready,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def reset()
+      NovaTa.rust_call(:uniffi_nova_ta_fn_method_ker_reset,uniffi_clone_handle(),)
+  end
+  
+  def update(input)
+        input = input
+        
+    result = NovaTa.rust_call_with_error(NovaError,:uniffi_nova_ta_fn_method_ker_update,uniffi_clone_handle(),input)
+    return result.to_f
+  end
+  
+end
+  
+end
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: nova_ta
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: x64-mingw-ucrt
+authors:
+- Rick-29
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+description: Ruby bindings (via UniFFI) for the nova-ta Rust crate.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/nova_ta.dll
+- lib/nova_ta.rb
+homepage: https://github.com/Rick-29/nova
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Stateful technical-analysis indicators for real-time data.
+test_files: []