sys-cpu 0.6.2-x86-mingw32

data/ext/version.h

@@ -0,0 +1,2 @@
+/* version.h - one version to rule them all */
+#define SYS_CPU_VERSION "0.6.2"

data/install.rb

@@ -0,0 +1,84 @@
+#######################################################################
+# install.rb
+#
+# For pure Ruby versions only. Generally speaking this script should
+# not be run directly. Use the 'rake install' task instead.
+#######################################################################
+require 'rbconfig'
+require 'fileutils'
+include Config
+install_dir = File.join(CONFIG['sitelibdir'], 'sys')
+
+file = ""
+
+case CONFIG['host_os']
+  when /windows|win32|mingw|cygwin|dos/i
+    file = "lib/windows/sys/cpu.rb"
+  when /linux/i
+    file = "lib/linux/sys/cpu.rb"
+  when /sunos|solaris|hpux|freebsd/i
+    STDERR.puts "Use 'extconf.rb/make/make site-install' for this platform"
+    exit
+  else
+    STDERR.puts "This platform is not currently supported.  Exiting..."
+    exit
+end
+
+#######################################################################
+# Dynamically generate some of the documentation for linux.  If the
+# doc size is already greater than 1.4k, assume that the documentation
+# has already been written at some point previously and skip it.
+#######################################################################
+if CONFIG['host_os'] =~ /linux/
+   cpu_file = "/proc/cpuinfo"
+   text_file = "doc/linux.txt"
+   rb_file  = "lib/linux/sys/cpu.rb"
+
+   if File.size(text_file) > 1400
+      puts "You appear to have already created the documentation."
+      puts "Skipping..."
+   else
+      puts "Dynamically generating documentation..."
+      fh = File.open(text_file,"a+")
+
+      IO.foreach(cpu_file){ |line|
+         next if line =~ /^$/
+         k,v = line.split(":")
+         v.strip!.chomp!
+         k.strip!.gsub!(/\s+/,"_")
+         k.downcase!
+         if v =~ /yes|no/i
+	        k += "?"
+         end
+         fh.puts("CPU.#{k}")
+         if v =~ /yes|no/i
+	        k.chop!
+	        msg = "     Returns true if a " + k.gsub(/_/," ") + "exists on"
+	        msg << " this system"
+	        fh.puts(msg)
+         else
+	        fh.puts("     Returns the " + k.gsub(/_/," "))
+         end
+         fh.puts # Add a blank line
+      }
+
+      fh.puts(doc)
+      fh.close
+      puts "Documentation creation complete"
+   end
+end
+
+# Create the 'sys' toplevel directory if it doesn't already exist
+begin
+  unless File.exist?(install_dir)
+    Dir.mkdir(install_dir)
+  end
+rescue Errno::EACCES => e
+  puts "Unable to create #{install_dir}: #{e}"
+  exit
+end
+
+# Finally, copy the file to the appropriate directory
+FileUtils.cp(file, "#{install_dir}/cpu.rb", :verbose => true)
+
+puts "Installation successful"

data/lib/linux/sys/cpu.rb

@@ -0,0 +1,122 @@
+##########################################################
+# linux.rb (sys-cpu) - pure Ruby version for Linux
+##########################################################
+module Sys
+
+  # :stopdoc:
+  
+  cpu_file   = "/proc/cpuinfo"
+  cpu_hash   = {}
+  $cpu_array = []
+
+  # Parse the info out of the /proc/cpuinfo file
+  IO.foreach(cpu_file){ |line|
+    line.strip!
+    next if line.empty?
+
+    key, val = line.split(":")
+    key.strip!
+    key.gsub!(/\s+/,"_")
+    key.downcase!
+    val.strip! if val
+
+    if cpu_hash.has_key?(key)
+      $cpu_array.push(cpu_hash.dup)
+      cpu_hash.clear
+    end
+      
+    # Turn yes/no attributes into booleans
+    if val == 'yes'
+      val = true
+    elsif val == 'no'
+      val = false
+    end
+
+    cpu_hash[key] = val
+  }
+
+  $cpu_array.push(cpu_hash)
+
+  # :startdoc:
+
+  class CPU
+
+    # The version of the sys-cpu library.
+    VERSION = '0.6.2'
+
+    # :stopdoc:
+
+    CPUStruct = Struct.new("CPUStruct", *$cpu_array.first.keys)
+
+    # :startdoc:
+
+    # In block form, yields a CPUStruct for each CPU on the system.  In
+    # non-block form, returns an Array of CPUStruct's.
+    #
+    # The exact members of the struct vary on Linux systems.
+    #
+    def self.processors
+      array = []
+      $cpu_array.each{ |hash|
+        struct = CPUStruct.new
+        struct.members.each{ |m| struct.send("#{m}=", hash[m]) }
+        if block_given?
+          yield struct
+        else
+          array << struct
+        end
+      }
+      array unless block_given?
+    end
+
+    private
+
+    # Create singleton methods for each of the attributes.
+    #
+    def self.method_missing(id, arg=0)
+      rv = $cpu_array[arg][id.to_s]
+      if rv.nil?
+        id = id.to_s + "?"
+        rv = $cpu_array[arg][id]
+      end
+      rv
+    end
+
+    public
+
+    # Returns a 3 element Array corresponding to the 1, 5 and 15 minute
+    # load average for the system.
+    #
+    def self.load_avg
+      load_avg_file = "/proc/loadavg"
+      IO.readlines(load_avg_file).first.split[0..2].map{ |e| e.to_f }
+    end
+
+    # Returns a hash of arrays that contain the number of seconds that the
+    # system spent in user mode, user mode with low priority (nice), system
+    # mode, and the idle task, respectively.
+    #
+    def self.cpu_stats
+      cpu_stat_file = "/proc/stat"
+      hash = {} # Hash needed for multi-cpu systems
+
+      lines = IO.readlines(cpu_stat_file)
+
+      lines.each_with_index{ |line, i|
+        array = line.split
+        break unless array[0] =~ /cpu/   # 'cpu' entries always on top
+            
+        # Some machines list a 'cpu' and a 'cpu0'. In this case only
+        # return values for the numbered cpu entry.
+        if lines[i].split[0] == "cpu" && lines[i+1].split[0] =~ /cpu\d/
+          next
+        end
+
+        vals = array[1..-1].map{ |e| e = e.to_i / 100 } # 100 jiffies/sec.
+        hash[array[0]] = vals
+      }
+
+      hash
+    end
+  end
+end

data/lib/windows/sys/cpu.rb

@@ -0,0 +1,784 @@
+require 'win32ole'
+require 'socket'
+
+# The Sys module serves only as a namespace
+module Sys
+   # Encapsulates system CPU information
+   class CPU
+      # Error raised if any of the Sys::CPU methods fail.
+      class Error < StandardError; end
+
+      # The version of this library
+      VERSION = '0.6.2'
+
+      # Base connect string
+      BASE_CS = "winmgmts:{impersonationLevel=impersonate}" # :nodoc:
+      
+      # Fields used in the CPUStruct
+      fields = %w/
+         address_width
+         architecture
+         availability
+         caption
+         config_manager_error_code
+         config_manager_user_config
+         cpu_status
+         creation_class_name
+         freq
+         voltage
+         data_width
+         description
+         device_id
+         error_cleared?
+         error_description
+         ext_clock
+         family
+         install_date
+         l2_cache_size
+         l2_cache_speed
+         last_error_code
+         level
+         load_avg
+         manufacturer
+         max_clock_speed
+         name
+         other_family_description
+         pnp_device_id
+         power_management_supported?
+         power_management_capabilities
+         processor_id
+         processor_type
+         revision
+         role
+         socket_designation
+         status
+         status_info
+         stepping
+         system_creation_class_name
+         system_name
+         unique_id
+         upgrade_method
+         version
+         voltage_caps
+      /
+      
+      # The struct returned by the CPU.processors method
+      CPUStruct = Struct.new("CPUStruct", *fields) # :nodoc:
+      
+      # Returns the +host+ CPU's architecture, or nil if it cannot be
+      # determined.
+      #
+      def self.architecture(host=Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"     
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            self.get_cpu_arch(wmi.Architecture)
+         end
+      end
+      
+      # Returns an integer indicating the speed (i.e. frequency in Mhz) of
+      # +cpu_num+ on +host+, or the localhost if no +host+ is specified.
+      # If +cpu_num+ +1 is greater than the number of cpu's on your system
+      # or this call fails for any other reason, a Error is raised.
+      #
+      def self.freq(cpu_num = 0, host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu#{cpu_num}'"    
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.CurrentClockSpeed
+         end
+      end
+      
+      # Returns the load capacity for +cpu_num+ on +host+, or the localhost
+      # if no host is specified, averaged to the last second. Processor
+      # loading refers to the total computing burden for each processor at
+      # one time.
+      #
+      # Note that this attribute is actually the LoadPercentage.  I may use
+      # one of the Win32_Perf* classes in the future.
+      #
+      def self.load_avg(cpu_num = 0, host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu#{cpu_num}'"    
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.LoadPercentage
+         end    
+      end
+      
+      # Returns a string indicating the cpu model, e.g. Intel Pentium 4.
+      #
+      def self.model(host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"    
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.Name
+         end
+      end
+      
+      # Returns an integer indicating the number of cpu's on the system.
+      #--
+      # This (oddly) requires a different class.
+      #
+      def self.num_cpu(host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_ComputerSystem='#{host}'"
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.NumberOfProcessors
+         end
+      end
+      
+      # Returns a CPUStruct for each CPU on +host+, or the localhost if no
+      # +host+ is specified.  A CPUStruct contains the following members:
+      #
+      # * address_width
+      # * architecture
+      # * availability
+      # * caption
+      # * config_manager_error_code
+      # * config_manager_user_config
+      # * cpu_status
+      # * creation_class_name
+      # * freq
+      # * voltage
+      # * data_width
+      # * description
+      # * device_id
+      # * error_cleared?
+      # * error_description
+      # * ext_clock
+      # * family
+      # * install_date
+      # * l2_cache_size
+      # * l2_cache_speed
+      # * last_error_code
+      # * level
+      # * load_avg
+      # * manufacturer
+      # * max_clock_speed
+      # * name
+      # * other_family_description
+      # * pnp_device_id
+      # * power_management_supported?
+      # * power_management_capabilities
+      # * processor_id
+      # * processor_type
+      # * revision
+      # * role
+      # * socket_designation
+      # * status
+      # * status_info
+      # * stepping
+      # * system_creation_class_name
+      # * system_name
+      # * unique_id
+      # * upgrade_method
+      # * version
+      # * voltage_caps
+      #
+      # Note that not all of these members will necessarily be defined.
+      #
+      def self.processors(host = Socket.gethostname) # :yields: CPUStruct
+         begin
+            wmi = WIN32OLE.connect(BASE_CS + "//#{host}/root/cimv2")
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            wmi.InstancesOf("Win32_Processor").each{ |cpu|
+               yield CPUStruct.new(
+                  cpu.AddressWidth,
+                  self.get_cpu_arch(cpu.Architecture),
+                  self.get_availability(cpu.Availability),
+                  cpu.Caption,
+                  self.get_cmec(cpu.ConfigManagerErrorCode),
+                  cpu.ConfigManagerUserConfig,
+                  get_status(cpu.CpuStatus),
+                  cpu.CreationClassName,
+                  cpu.CurrentClockSpeed,
+                  cpu.CurrentVoltage,
+                  cpu.DataWidth,
+                  cpu.Description,
+                  cpu.DeviceId,
+                  cpu.ErrorCleared,
+                  cpu.ErrorDescription,
+                  cpu.ExtClock,
+                  self.get_family(cpu.Family),
+                  cpu.InstallDate,
+                  cpu.L2CacheSize,
+                  cpu.L2CacheSpeed,
+                  cpu.LastErrorCode,
+                  cpu.Level,
+                  cpu.LoadPercentage,
+                  cpu.Manufacturer,
+                  cpu.MaxClockSpeed,
+                  cpu.Name,
+                  cpu.OtherFamilyDescription,
+                  cpu.PNPDeviceID,
+                  cpu.PowerManagementSupported,
+                  cpu.PowerManagementCapabilities,
+                  cpu.ProcessorId,
+                  self.get_processor_type(cpu.ProcessorType),
+                  cpu.Revision,
+                  cpu.Role,
+                  cpu.SocketDesignation,
+                  cpu.Status,
+                  cpu.StatusInfo,
+                  cpu.Stepping,
+                  cpu.SystemCreationClassName,
+                  cpu.SystemName,
+                  cpu.UniqueId,
+                  self.get_upgrade_method(cpu.UpgradeMethod),
+                  cpu.Version,
+                  self.get_voltage_caps(cpu.VoltageCaps)
+               )
+            }
+         end           
+      end
+
+      # Returns a string indicating the type of processor, e.g. GenuineIntel.
+      #
+      def self.type(host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"    
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.Manufacturer
+         end
+      end
+            
+      private
+      
+      # Convert the ConfigManagerErrorCode number to its corresponding string
+      # Note that this value returns nil on my system.
+      #
+      def self.get_cmec(num)
+         case
+            when 0
+               str = "The device is working properly."
+               return str
+            when 1
+               str = "The device is not configured correctly."
+               return str
+            when 2
+               str = "Windows cannot load the driver for the device."
+               return str
+            when 3
+               str = "The driver for the device might be corrupted, or the"
+               str << " system may be running low on memory or other"
+               str << " resources."
+               return str
+            when 4
+               str = "The device is not working properly. One of the drivers"
+               str << " or the registry might be corrupted."
+               return str
+            when 5
+               str = "The driver for this device needs a resource that"
+               str << " Windows cannot manage."
+               return str
+            when 6
+               str = "The boot configuration for this device conflicts with"
+               str << " other devices."
+               return str
+            when 7
+               str = "Cannot filter."
+               return str
+            when 8
+               str = "The driver loader for the device is missing."
+               return str
+            when 9
+               str = "This device is not working properly because the"
+               str << " controlling firmware is reporting the resources"
+               str << " for the device incorrectly."
+               return str
+            when 10
+               str = "This device cannot start."
+               return str
+            when 11
+               str = "This device failed."
+               return str
+            when 12
+               str = "This device cannot find enough free resources that"
+               str << " it can use."
+               return str
+            when 13
+               str = "Windows cannot verify this device's resources."
+               return str
+            when 14
+               str = "This device cannot work properly until you restart"
+               str << " your computer."
+               return str
+            when 15
+               str = "This device is not working properly because there is"
+               str << " probably a re-enumeration problem."
+               return str
+            when 16
+               str = "Windows cannot identify all the resources this device "
+               str << " uses."
+               return str
+            when 17
+               str = "This device is asking for an unknown resource type."
+               return str
+            when 18
+               str = "Reinstall the drivers for this device."
+               return str
+            when 19
+               str = "Failure using the VXD loader."
+               return str
+            when 20
+               str = "Your registry might be corrupted."
+               return str
+            when 21
+               str = "System failure: try changing the driver for this device."
+               str << " If that does not work, see your hardware documentation."
+               str << " Windows is removing this device."
+               return str
+            when 22
+               str = "This device is disabled."
+               return str
+            when 23
+               str = "System failure: try changing the driver for this device."
+               str << "If that doesn't work, see your hardware documentation."
+               return str
+            when 24
+               str = "This device is not present, not working properly, or"
+               str << " does not have all its drivers installed."
+               return str
+            when 25
+               str = "Windows is still setting up this device."
+               return str
+            when 26
+               str = "Windows is still setting up this device."
+               return str
+            when 27
+               str = "This device does not have valid log configuration."
+               return str
+            when 28
+               str = "The drivers for this device are not installed."
+               return str
+            when 29
+               str = "This device is disabled because the firmware of the"
+               str << " device did not give it the required resources."
+               return str
+            when 30
+               str = "This device is using an Interrupt Request (IRQ)"
+               str << " resource that another device is using."
+               return str
+            when 31
+               str = "This device is not working properly because Windows"
+               str << " cannot load the drivers required for this device"
+               return str
+            else
+               return nil
+         end
+      end
+      
+      # Convert an cpu architecture number to a string
+      def self.get_cpu_arch(num)
+         case num
+            when 0
+               return "x86"
+            when 1
+               return "MIPS"
+            when 2
+               return "Alpha"
+            when 3
+               return "PowerPC"
+            when 4
+               return "IA64"
+            else
+               return nil
+         end
+      end
+      
+      # convert an Availability number into a string
+      def self.get_availability(num)
+         case num
+            when 1
+               return "Other"
+            when 2
+               return "Unknown"
+            when 3
+               return "Running"
+            when 4
+               return "Warning"
+            when 5
+               return "In Test"
+            when 6
+               return "Not Applicable"
+            when 7
+               return "Power Off"
+            when 8
+               return "Off Line"
+            when 9
+               return "Off Duty"
+            when 10
+               return "Degraded"
+            when 11
+               return "Not Installed"
+            when 12
+               return "Install Error"
+            when 13
+               return "Power Save - Unknown"
+            when 14
+               return "Power Save - Low Power Mode"
+            when 15
+               return "Power Save - Standby"
+            when 16
+               return "Power Cycle"
+            when 17
+               return "Power Save - Warning"
+            when 18
+               return "Paused"
+            when 19
+               return "Not Ready"
+            when 20
+               return "Not Configured"
+            when 21
+               return "Quiesced"
+            else
+               return nil
+         end     
+      end
+      
+      # convert CpuStatus to a string form.  Note that values 5 and 6 are
+      # skipped because they're reserved.
+      def self.get_status(num)
+         case num
+            when 0
+               return "Unknown"
+            when 1
+               return "Enabled"
+            when 2
+               return "Disabled by User via BIOS Setup"
+            when 3
+               return "Disabled By BIOS (POST Error)"
+            when 4
+               return "Idle"
+            when 7
+               return "Other"
+            else
+               return nil
+         end
+      end
+      
+      # Convert a family number into the equivalent string
+      def self.get_family(num)
+         case num
+            when 1
+               return "Other"
+		    when 2
+		       return "Unknown"
+		    when 3
+		       return "8086"
+		    when 4
+		       return "80286"
+		    when 5
+		       return "80386"
+		    when 6
+		       return "80486"
+		    when 7
+		       return "8087"
+		    when 8
+		       return "80287"
+		    when 9
+		       return "80387"
+		    when 10
+		       return "80487"
+		    when 11
+		       return "Pentium?"
+		    when 12
+		       return "Pentium?"
+		    when 13
+		       return "Pentium?"
+		    when 14
+		       return "Pentium?"
+		    when 15
+		       return "Celeron?"
+		    when 16
+		       return "Pentium?"
+		    when 17
+		       return "Pentium?"
+		    when 18
+		       return "M1"
+		    when 19
+		       return "M2"
+		    when 24
+		       return "K5"
+		    when 25
+		       return "K6"
+		    when 26
+		       return "K6-2"
+		    when 27
+		       return "K6-3"
+		    when 28
+		       return "AMD"
+		    when 29
+		       return "AMD?"
+		    when 30
+		       return "AMD2900"
+		    when 31
+		       return "K6-2+"
+		    when 32
+		       return "Power"
+		    when 33
+		       return "Power"
+		    when 34
+		       return "Power"
+		    when 35
+		       return "Power"
+		    when 36
+		       return "Power"
+		    when 37
+		       return "Power"
+		    when 38
+		       return "Power"
+		    when 39
+		       return "Power"
+		    when 48
+		       return "Alpha"
+		    when 49
+		       return "Alpha"
+		    when 50
+		       return "Alpha"
+		    when 51
+		       return "Alpha"
+		    when 52
+		       return "Alpha"
+		    when 53
+		       return "Alpha"
+		    when 54
+		       return "Alpha"
+		    when 55
+		       return "Alpha"
+		    when 64
+		       return "MIPS"
+		    when 65
+		       return "MIPS"
+		    when 66
+		       return "MIPS"
+		    when 67
+		       return "MIPS"
+		    when 68
+		       return "MIPS"
+		    when 69
+		       return "MIPS"
+		    when 80
+		       return "SPARC"
+		    when 81
+		       return "SuperSPARC"
+		    when 82
+		       return "microSPARC"
+		    when 83
+		       return "microSPARC"
+		    when 84
+		       return "UltraSPARC"
+		    when 85
+		       return "UltraSPARC"
+		    when 86
+		       return "UltraSPARC"
+		    when 87
+		       return "UltraSPARC"
+		    when 88
+		       return "UltraSPARC"
+		    when 96
+		       return "68040"
+		    when 97
+		       return "68xxx"
+		    when 98
+		       return "68000"
+		    when 99
+		       return "68010"
+		    when 100
+		       return "68020"
+		    when 101
+		       return "68030"
+		    when 112
+		       return "Hobbit"
+		    when 120
+		       return "Crusoe?"
+		    when 121
+		       return "Crusoe?"
+		    when 128
+		       return "Weitek"
+		    when 130
+		       return "Itanium?"
+		    when 144
+		       return "PA-RISC"
+		    when 145
+		       return "PA-RISC"
+		    when 146
+		       return "PA-RISC"
+		    when 147
+		       return "PA-RISC"
+		    when 148
+	           return "PA-RISC"
+		    when 149
+		       return "PA-RISC"
+		    when 150
+		       return "PA-RISC"
+		    when 160
+		       return "V30"
+		    when 176
+		       return "Pentium?"
+		    when 177
+		       return "Pentium?"
+		    when 178
+		       return "Pentium?"
+		    when 179
+		       return "Intel?"
+		    when 180
+		       return "AS400"
+		    when 181
+		       return "Intel?"
+		    when 182
+		       return "AMD"
+		    when 183
+		       return "AMD"
+		    when 184
+		       return "Intel?"
+		    when 185
+		       return "AMD"
+		    when 190
+		       return "K7"
+		    when 200
+		       return "IBM390"
+		    when 201
+		       return "G4"
+		    when 202
+		       return "G5"
+		    when 250
+		       return "i860"
+		    when 251
+		       return "i960"
+		    when 260
+		       return "SH-3"
+		    when 261
+		       return "SH-4"
+		    when 280
+		       return "ARM"
+		    when 281
+		       return "StrongARM"
+		    when 300
+		       return "6x86"
+		    when 301
+		       return "MediaGX"
+		    when 302
+		       return "MII"
+		    when 320
+		       return "WinChip"
+		    when 350
+		       return "DSP"
+		    when 500
+		       return "Video"
+		    else
+		       return nil
+	     end
+      end
+      
+      # Convert power management capabilities number to its equivalent string
+      def self.get_pmc(num)
+         case num
+            when 0
+               return "Unknown"
+            when 1
+               return "Not Supported"
+            when 2
+               return "Disabled"
+            when 3
+               return "Enabled"
+            when 4
+               return "Power Saving Modes Entered Automatically"
+            when 5
+               return "Power State Settable"
+            when 6
+               return "Power Cycling Supported"
+            when 7
+               return "Timed Power On Supported"
+            else
+               return nil
+         end
+      end
+      
+      # Convert a processor type into its equivalent string
+      def self.get_processor_type(num)
+         case num
+            when 1
+               return "Other"
+            when 2
+               return "Unknown"
+            when 3
+               return "Central Processor"
+            when 4
+               return "Math Processor"
+            when 5
+               return "DSP Processor"
+            when 6
+               return "Video Processor"
+            else
+               return nil
+         end
+      end
+      
+      # Convert an upgrade method into its equivalent string
+      def self.get_upgrade_method(num)
+         case num
+            when 1
+               return "Other"
+            when 2
+               return "Unknown"
+            when 3
+               return "Daughter Board"
+            when 4
+               return "ZIF Socket"
+            when 5
+               return "Replacement/Piggy Back"
+            when 6
+               return "None"
+            when 7
+               return "LIF Socket"
+            when 8
+               return "Slot 1"
+            when 9
+               return "Slot 2"
+            when 10
+               return "370 Pin Socket"
+            when 11
+               return "Slot A"
+            when 12
+               return "Slot M"
+            else
+               return nil
+         end
+      end
+      
+      # Convert return values to voltage cap values (floats)
+      def self.get_voltage_caps(num)
+         case num
+            when 1
+               return 5.0
+            when 2
+               return 3.3
+            when 4
+               return 2.9
+            else
+               return nil
+         end
+      end
+   end
+end