Class: VirtualBox::COM::Implementer::MSCOM

178
179
180
181
182
183
184
185

# File 'lib/virtualbox/com/implementer/mscom.rb', line 178

def read_array_of_interface(value, type)
  klass = interface_klass(type.first)
  value.collect do |item|
    if !item.nil?
      klass.new(self.class, lib, item)
    end
  end
end

173
174
175
176

# File 'lib/virtualbox/com/implementer/mscom.rb', line 173

def read_array_of_unicode_string(value, type)
  # Return as-is, since MSCOM returns ruby strings!
  value
end

139
140
141
142

# File 'lib/virtualbox/com/implementer/mscom.rb', line 139

def read_char(value, type)
  # Convert to a boolean
  !(value.to_s == "0")
end

164
165
166

# File 'lib/virtualbox/com/implementer/mscom.rb', line 164

def read_enum(value, type)
  interface_klass(type)[value]
end

156
157
158

# File 'lib/virtualbox/com/implementer/mscom.rb', line 156

def read_int(value, type)
  value.to_i
end

168
169
170
171

# File 'lib/virtualbox/com/implementer/mscom.rb', line 168

def read_interface(value, type)
  return nil if value.nil?
  interface_klass(type).new(self.class, lib, value)
end

160
161
162

# File 'lib/virtualbox/com/implementer/mscom.rb', line 160

def read_long(value, type)
  value.to_i
end

18
19
20
21
22
23
24
25
26
27
28
29
30

# File 'lib/virtualbox/com/implementer/mscom.rb', line 18

def read_property(name, opts)
  # First get the basic value from the COM object
  method = COM::FFI::Util.camelize(name.to_s)
  value = if ruby_version >= 1.9
    @object.send(method)
  else
    @object[method]
  end

  # Then depending on the value type, we either return as-is or
  # must wrap it up in another interface class
  returnable_value(value, opts[:value_type])
end

148
149
150

# File 'lib/virtualbox/com/implementer/mscom.rb', line 148

def read_uint(value, type)
  value.to_i
end

152
153
154

# File 'lib/virtualbox/com/implementer/mscom.rb', line 152

def read_ulong(value, type)
  value.to_i
end

134
135
136
137

# File 'lib/virtualbox/com/implementer/mscom.rb', line 134

def read_unicode_string(value, type)
  # Return as-is
  value
end

144
145
146

# File 'lib/virtualbox/com/implementer/mscom.rb', line 144

def read_ushort(value, type)
  value.to_i
end

123
124
125
126
127
128
129
130
131
132

# File 'lib/virtualbox/com/implementer/mscom.rb', line 123

def returnable_value(value, type)
  # Types which are void or nil just return
  return nil if type.nil? || type == :void

  klass = type.is_a?(Array) ? type.first : type
  ignore, inferred_type = infer_type(klass)

  array_of = type.is_a?(Array) ? "array_of_" : ""
  send("read_#{array_of}#{inferred_type}", value, type)
end

82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

# File 'lib/virtualbox/com/implementer/mscom.rb', line 82

def single_type_to_arg(args, item, results)
  if item.is_a?(Array) && item.length == 1
    # Array argument
    data = args.shift

    # If its a regular type (int, bool, etc.) then just make it an
    # array of that
    results << data.inject([]) do |converted_data, single|
      single_type_to_arg([single], item[0], converted_data)
    end
  elsif item.to_s[0,1] == item.to_s[0,1].upcase
    # Try to get the class from the interfaces
    interface = interface_klass(item.to_sym)

    if interface.superclass == COM::AbstractInterface
      # For interfaces, get the instance, then dig deep to get the pointer
      # to the VtblParent, which is what the API expects
      instance = args.shift

      results << if !instance.nil?
        # Get the actual MSCOM object, rather than the AbstractInterface
        instance.implementer.object
      else
        # If the argument was nil, just pass a nil pointer as the argument
        nil
      end
    elsif interface.superclass == COM::AbstractEnum
      # For enums, we need the value of the enum
      results << interface.index(args.shift.to_sym)
    end
  elsif item == T_BOOL
    results << (args.shift ? 1 : 0)
  else
    # Simply replace spec item with next item in args
    # list
    results << args.shift
  end
end

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

# File 'lib/virtualbox/com/implementer/mscom.rb', line 63

def spec_to_args(spec, args)
  args = args.dup

  # First remove all :out parameters from the spec, since those are of no
  # concern for MSCOM at this point
  spec = spec.collect do |item|
    if item.is_a?(Array) && item[0] == :out
      nil
    else
      item
    end
  end.compact

  spec = spec.inject([]) do |results, item|
    single_type_to_arg(args, item, results)
  end
end

34
35
36
37
38
39
40
41
42
43
44

# File 'lib/virtualbox/com/implementer/mscom.rb', line 34

def write_property(name, value, opts)
  # Set the property with a prepared value
  method = COM::FFI::Util.camelize(name.to_s)
  value = spec_to_args([opts[:value_type]], [value]).first

  if ruby_version >= 1.9
    @object.send("#{method}=", value)
  else
    @object[method] = value
  end
end