openc3 5.0.6

data/lib/openc3/core_ext/exception.rb

@@ -0,0 +1,61 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+# OpenC3 specific additions to the Ruby Exception class
+class Exception
+  # @param hide_runtime_error_class [Boolean] Whether to hide the Exception
+  #   error class if the class is RuntimeError. Other classes will continue to
+  #   be printed.
+  # @param include_backtrace [Boolean] Whether to include the full exception
+  #   backtrace
+  # @return [String] The formatted Exception
+  def formatted(hide_runtime_error_class = false, include_backtrace = true)
+    if include_backtrace and self.backtrace
+      if hide_runtime_error_class and self.class == RuntimeError
+        "#{self.message}\n#{self.backtrace.join("\n")}"
+      else
+        "#{self.class.to_s.split('::')[-1]} : #{self.message}\n#{self.backtrace.join("\n")}"
+      end
+    else
+      if hide_runtime_error_class and self.class == RuntimeError
+        "#{self.message}"
+      else
+        "#{self.class.to_s.split('::')[-1]} : #{self.message}"
+      end
+    end
+  end
+
+  # @return [Array(String, Fixnum)] The filename and line number where the Exception
+  #   occurred
+  def source
+    trace = self.backtrace[0]
+    split_trace = trace.split(':')
+    filename = ''
+    line_number = ''
+    if trace[1..1] == ':' # Windows Path
+      filename = split_trace[0] + ':' + split_trace[1]
+      line_number = split_trace[2].to_i
+    else
+      filename = split_trace[0]
+      line_number = split_trace[1].to_i
+    end
+
+    [filename, line_number]
+  end
+end

data/lib/openc3/core_ext/file.rb

@@ -0,0 +1,83 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'find'
+
+# OpenC3 specific additions to the Ruby File class
+class File
+  # Non printable ASCII characters
+  NON_ASCII_PRINTABLE = /[^\x21-\x7e\s]/
+
+  # @return [Boolean] Whether the file only contains ASCII characters
+  def self.is_ascii?(filename)
+    return_value = true
+    File.open(filename) do |file|
+      while buf = file.read(1024)
+        if NON_ASCII_PRINTABLE.match?(buf)
+          return_value = false
+          break
+        end
+      end
+    end
+    return return_value
+  end
+
+  # Builds a String for use in creating a file. The time is formatted as
+  # YYYY_MM_DD_HH_MM_SS. The tags and joined with an underscore and appended to
+  # the date before appending the extension.
+  #
+  # For example:
+  #   File.build_timestamped_filename(['test','only'], '.bin', Time.now.sys)
+  #   # result is YYYY_MM_DD_HH_MM_SS_test_only.bin
+  #
+  # @param tags [Array<String>] An array of strings to be joined by underscores
+  #   after the date. Pass nil or an empty array to use no tags.
+  # @param extension [String] The filename extension
+  # @param time [Time] The time to format into the filename
+  # @return [String] The filename string containing the timestamp, tags, and
+  #   extension
+  def self.build_timestamped_filename(tags = nil, extension = '.txt', time = Time.now.sys)
+    timestamp = sprintf("%04u_%02u_%02u_%02u_%02u_%02u", time.year, time.month, time.mday, time.hour, time.min, time.sec)
+    tags ||= []
+    tags.compact!
+    combined_tags = tags.join("_")
+    if combined_tags.length > 0
+      filename = timestamp + "_" + combined_tags + extension
+    else
+      filename = timestamp + extension
+    end
+    return filename
+  end
+
+  # @param filename [String] The file to search for
+  # @return [String] The full path to the filename if it was found in the Ruby
+  #   search path. nil if the fild was not found.
+  def self.find_in_search_path(filename)
+    $:.each do |load_path|
+      Find.find(load_path) do |path|
+        Find.prune if /\.svn/.match?(path)
+        return path if File.basename(path) == filename
+      end
+    rescue Errno::ENOENT
+      # Ignore non-existent folders
+      next
+    end
+    return nil
+  end
+end

data/lib/openc3/core_ext/hash.rb

@@ -0,0 +1,37 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+# OpenC3 specific additions to the Ruby Hash class
+class Hash
+  # Redefine inspect to only print for small numbers of
+  # items.  Prevents exceptions taking forever to be raised with
+  # large objects.  See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/105145
+  alias old_inspect inspect
+
+  # @param max_elements [Integer] The maximum number of elements in the Hash to
+  #   print out before simply displaying the Hash class and object id
+  # @return [String] String representation of the hash
+  def inspect(max_elements = 10)
+    if self.length <= max_elements
+      old_inspect()
+    else
+      '#<' + self.class.to_s + ':' + self.object_id.to_s + '>'
+    end
+  end
+end

data/lib/openc3/core_ext/io.rb

@@ -0,0 +1,134 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/core_ext/kernel'
+require 'openc3/core_ext/openc3_io'
+
+class IO
+  include OpenC3IO
+
+  # Initial timeout to call IO.select with. Timeouts are increased by doubling
+  # this value until the SELET_MAX_TIMEOUT value is reached.
+  SELECT_BASE_TIMEOUT = 0.0004
+  # The maximum timeout at which point we call IO.select with whatever
+  # remaining timeout is left.
+  SELECT_MAX_TIMEOUT = 0.016
+
+  class << self
+    # Alias the original IO.select method
+    alias_method :__select__, :select
+
+    # On Windows the IO.select function (when called with no timeout) takes
+    # a minimum of 10 msec to return, even if one of the IO objects is
+    # ready to read/write sooner than that.
+    #
+    # This method is identical to IO.select but instead of calling IO.select with
+    # the full timeout, it calls IO.select with a small timeout and then
+    # doubles the timeout twice until eventually it calls IO.select with the
+    # remaining passed in timeout value.
+    #
+    # @param read_sockets [Array<IO>] IO objects to wait to be ready to read
+    # @param write_sockets [Array<IO>] IO objects to wait to be ready to write
+    # @param error_array [Array<IO>] IO objects to wait for exceptions
+    # @param timeout [Numeric] Number of seconds to wait
+    def fast_select(read_sockets = nil, write_sockets = nil, error_array = nil, timeout = nil)
+      # Always try a zero timeout first
+      current_timeout = SELECT_BASE_TIMEOUT
+      total_timeout = 0.0
+
+      while true
+        begin
+          result = IO.__select__(read_sockets, write_sockets, error_array, current_timeout)
+        # All OS errors are subclassed to SystemCallError as Errno::<Subclass>
+        # See https://ruby-doc.org/core-3.1.0/Errno.html
+        rescue SystemCallError
+          return nil
+        end
+        return result if result or current_timeout.nil?
+        return nil if timeout and total_timeout >= timeout
+
+        if current_timeout <= 0.0001
+          # Always try the base timeout next
+          current_timeout = SELECT_BASE_TIMEOUT
+          total_timeout = SELECT_BASE_TIMEOUT
+        else
+          # Then start doubling the timeout
+          current_timeout = current_timeout * 2
+
+          # Until it is bigger than our max timeout
+          if current_timeout >= SELECT_MAX_TIMEOUT
+            if timeout
+              # Block for the remaining requested timeout
+              current_timeout = timeout - total_timeout
+              total_timeout = timeout
+            else
+              # Or block forever
+              current_timeout = nil
+            end
+          else
+            # Or it is bigger than the given timeout
+            if timeout and current_timeout >= timeout
+              # Block for the remaining requested timeout
+              current_timeout = timeout - total_timeout
+              total_timeout = timeout
+            else
+              # Up our total time in select
+              total_timeout += current_timeout
+            end
+            if timeout and total_timeout > timeout
+              # Block for the remaining requested timeout
+              current_timeout = timeout - total_timeout
+              total_timeout = timeout
+            end
+          end
+          return nil if current_timeout and current_timeout < 0
+        end
+      end # while true
+    end # fast_select
+
+    # For non-windows systems, leave IO.select alone, but for windows
+    # monkey-patch IO.select to use our fast-select implementation.
+    if Kernel.is_windows?
+      def select(read_sockets = nil, write_sockets = nil, error_array = nil, timeout = nil)
+        return fast_select(read_sockets, write_sockets, error_array, timeout)
+      end
+    end
+
+    # @param read_sockets [Array<IO>] IO objects to wait to be ready to read
+    # @param timeout [Numeric] Number of seconds to wait
+    def fast_read_select(read_sockets, timeout)
+      return fast_select(read_sockets, nil, nil, timeout)
+    end
+
+    # @param write_sockets [Array<IO>] IO objects to wait to be ready to write
+    # @param timeout [Numeric] Number of seconds to wait
+    def fast_write_select(write_sockets, timeout)
+      return fast_select(nil, write_sockets, nil, timeout)
+    end
+  end
+
+  # Alias the original close method
+  alias_method :__close__, :close
+
+  # Patch the close method so that it won't raise any exceptions
+  def close
+    __close__
+  rescue
+  end
+end

data/lib/openc3/core_ext/kernel.rb

@@ -0,0 +1,42 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+# OpenC3 specific additions to the Ruby Kernel module
+module Kernel
+  # @return [Boolean] Whether the current platform is Windows
+  def is_windows?
+    Gem.win_platform?
+  end
+
+  # @return [Boolean] Whether the current platform is Mac
+  def is_mac?
+    _, platform, *_ = RUBY_PLATFORM.split("-")
+    result = false
+    if /darwin/.match?(platform)
+      result = true
+    end
+    return result
+  end
+
+  # @param start [Integer] The number of stack entries to skip
+  # @return [Symbol] The name of the calling method
+  def calling_method(start = 1)
+    caller[start][/`([^']*)'/, 1].intern
+  end
+end

data/lib/openc3/core_ext/math.rb

@@ -0,0 +1,128 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+# OpenC3 specific additions to the Ruby Math module. The algorithms implemented
+# here are based on standard deviation algorithms based on Wikipedia Algorithms
+# for calculating variance, Section 3.
+module Math
+  # Add all the module instance methods as module functions so we can call them
+  # either as Math.sin_squared or directly if we "include Math"
+  extend self
+
+  # Power reduction formula. Calculates sin squared which is
+  # (1 - cos(2 * angle)) / 2
+  #
+  # @param angle [Float] Angle in degrees
+  # @return [Float] sin(angle) squared
+  def sin_squared(angle)
+    return (1.0 - Math.cos(2.0 * angle)) / 2.0
+  end
+
+  # Power reduction formula. Calculates cos squared which is
+  # (1 + cos(2 * angle)) / 2
+  #
+  # @param angle [Float] Angle in degrees
+  # @return [Float] cos(angle) squared
+  def cos_squared(angle)
+    return (1.0 + Math.cos(2.0 * angle)) / 2.0
+  end
+
+  # Calculates the population variance of a group of numbers. If the population
+  # is finite the population variance is the variance of the underlying
+  # probability distribution.
+  #
+  # @param array [Array<Numeric>] Array of values
+  # @return [Float, Float] The first value is the mean and the second is the
+  #   variance
+  def variance_population(array)
+    mean, m2, num_values = variance_generic(array)
+    if num_values != 0.0
+      return [mean, m2 / num_values]
+    else
+      return [mean, 0.0]
+    end
+  end
+
+  # Calculates the sample variance of a group of numbers. If the population of
+  # numbers is very large, it is not possible to count every value in the
+  # population, so the computation must be performed on a sample of the
+  # population.
+  #
+  # @param array [Array<Numeric>] Array of values
+  # @return [Float, Float] The first value is the mean and the second is the
+  #   variance
+  def variance_sample(array)
+    mean, m2, num_values = variance_generic(array)
+    if num_values != 1.0
+      return [mean, m2 / (num_values - 1.0)]
+    else
+      return [mean, 0.0]
+    end
+  end
+
+  # Calculates the standard deviation of the population variation by taking the
+  # square root of the population variance.
+  #
+  # @param array [Array<Numeric>] Array of values
+  # @return [Float, Float] The first value is the mean and the second is the
+  #   standard deviation
+  def stddev_population(array)
+    mean, variance = self.variance_population(array)
+    return [mean, Math.sqrt(variance)]
+  end
+
+  # Calculates the standard deviation of the sample variation by taking the
+  # square root of the sample variance.
+  #
+  # @param array [Array<Numeric>] Array of values
+  # @return [Float, Float] The first value is the mean and the second is the
+  #   standard deviation
+  def stddev_sample(array)
+    mean, variance = self.variance_sample(array)
+    return [mean, Math.sqrt(variance)]
+  end
+
+  # Calculates luma, the brightness, given RGB values.
+  #
+  # @param red [Numeric] Red RGB value (0 - 255)
+  # @param green [Numeric] Green RGB value (0 - 255)
+  # @param blue [Numeric] Blue RGB value (0 - 255)
+  # @return [Float] The calculated luma
+  def luma_from_rgb_max_255(red, green, blue)
+    (0.2126 * (red.to_f / 255.0)) + (0.7152 * (green.to_f / 255.0)) + (0.0722 * (blue.to_f / 255.0))
+  end
+
+  protected
+
+  def variance_generic(array)
+    num_values = 0.0
+    mean = 0.0
+    m2 = 0.0
+
+    array.each do |value|
+      value = value.to_f # so we work for arrays of floats or ints
+      num_values += 1.0
+      delta = value - mean
+      mean = mean + (delta / num_values)
+      m2 = m2 + delta * (value - mean)
+    end
+
+    return [mean, m2, num_values]
+  end
+end

data/lib/openc3/core_ext/matrix.rb

@@ -0,0 +1,156 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'matrix'
+include Math
+
+# OpenC3 specific additions to the Ruby Matrix class
+class Matrix
+  old_verbose = $VERBOSE; $VERBOSE = nil
+  # Allow [i] to return an entire row instead of being forced to pass both the
+  # row and column (i.e [i,j]) to return an individual element.
+  #
+  # @param i [Integer] Row index
+  # @param j [Integer] Optional column index. Pass nil to return the entire row
+  #   given by i.
+  # @return Either the row as an Array or the element
+  def [](i, j = nil)
+    if j
+      @rows[i][j]
+    else
+      @rows[i]
+    end
+  end
+  $VERBOSE = old_verbose
+
+  # Allow [i,j] = x to set the element at row i, column j to value x
+  #
+  # @param i [Integer] Row index
+  # @param j [Integer] Column index
+  # @param value [Object] The value to set
+  def []=(i, j, value)
+    @rows[i][j] = value
+  end
+
+  # Creates a rotation matrix around one axis as defined by:
+  # http://mathworld.wolfram.com/RotationMatrix.html
+  #
+  # @param axis [Symbol] Must be :X,:x,1, or :Y,:y,2, or :Z,:z,3
+  # @param rotation_angle_in_radians [Float] The rotation angle in radians to
+  #   rotate the maxtrix about the given axis
+  #
+  def self.rot(axis, rotation_angle_in_radians)
+    rotation_matrix = Matrix.identity(3).to_a
+
+    case axis
+    when :X, :x, 1
+      rotation_matrix[1][1] = cos(rotation_angle_in_radians)
+      rotation_matrix[1][2] = sin(rotation_angle_in_radians)
+      rotation_matrix[2][2] = rotation_matrix[1][1]
+      rotation_matrix[2][1] = -(rotation_matrix[1][2])
+    when :Y, :y, 2
+      rotation_matrix[0][0] = cos(rotation_angle_in_radians)
+      rotation_matrix[2][0] = sin(rotation_angle_in_radians)
+      rotation_matrix[2][2] = rotation_matrix[0][0]
+      rotation_matrix[0][2] = -(rotation_matrix[2][0])
+    when :Z, :z, 3
+      rotation_matrix[0][0] = cos(rotation_angle_in_radians)
+      rotation_matrix[0][1] = sin(rotation_angle_in_radians)
+      rotation_matrix[1][1] = rotation_matrix[0][0]
+      rotation_matrix[1][0] = -(rotation_matrix[0][1])
+    end
+
+    return Matrix[*rotation_matrix]
+  end
+
+  # Sums the diagonal values of the matrix
+  def trace
+    sum = 0.0
+    @rows.length.times do |index|
+      value = @rows[index][index]
+      if not value.nil?
+        sum += value
+      else
+        break
+      end
+    end
+    return sum
+  end
+
+  def self.cfromq(quaternion)
+    result = Matrix.zero(3)
+
+    tx = 2.0 * quaternion.x
+    ty = 2.0 * quaternion.y
+    tz = 2.0 * quaternion.z
+    twx = tx * quaternion.w
+    twy = ty * quaternion.w
+    twz = tz * quaternion.w
+    txx = tx * quaternion.x
+    txy = ty * quaternion.x
+    txz = tz * quaternion.x
+    tyy = ty * quaternion.y
+    tyz = tz * quaternion.y
+    tzz = tz * quaternion.z
+
+    result[0][0] = 1.0 - tyy - tzz
+    result[0][1] = txy + twz
+    result[0][2] = txz - twy
+    result[1][0] = txy - twz
+    result[1][1] = 1.0 - txx - tzz
+    result[1][2] = tyz + twx
+    result[2][0] = txz + twy
+    result[2][1] = tyz - twx
+    result[2][2] = 1.0 - txx - tyy
+
+    return result
+  end
+
+  def trans4(x, y, z)
+    @rows[3][0] += x * @rows[0][0] + y * @rows[1][0] + z * @rows[2][0]
+    @rows[3][1] += x * @rows[0][1] + y * @rows[1][1] + z * @rows[2][1]
+    @rows[3][2] += x * @rows[0][2] + y * @rows[1][2] + z * @rows[2][2]
+    @rows[3][3] += x * @rows[0][3] + y * @rows[1][3] + z * @rows[2][3]
+    return self
+  end
+
+  def scale4(x, y, z)
+    @rows[0][0] *= x; @rows[0][1] *= x; @rows[0][2] *= x; @rows[0][3] *= x
+    @rows[1][0] *= y; @rows[1][1] *= y; @rows[1][2] *= y; @rows[1][3] *= y
+    @rows[2][0] *= z; @rows[2][1] *= z; @rows[2][2] *= z; @rows[2][3] *= z
+    return self
+  end
+
+  def rot4(quaternion)
+    # Get rotation matrix
+    r = Matrix.cfromq(quaternion)
+
+    4.times do |row|
+      x = @rows[0][row]
+      y = @rows[1][row]
+      z = @rows[2][row]
+      3.times do |i|
+        @rows[i][row] = x * r[i][0] + y * r[i][1] + z * r[i][2]
+      end
+    end
+    # Ensure the final row is floating point for consistency
+    @rows[3].map! { |x| x.to_f }
+    return self
+  end
+end

data/lib/openc3/core_ext/objectspace.rb

@@ -0,0 +1,36 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+# OpenC3 specific additions to the ObjectSpace class
+module ObjectSpace
+  def self.find(klass)
+    ObjectSpace.each_object(klass) do |object|
+      return object
+    end
+    nil
+  end
+
+  def self.find_all(klass)
+    objects = []
+    ObjectSpace.each_object(klass) do |object|
+      objects << object
+    end
+    objects
+  end
+end # class ObjectSpace