Class: VirtualBox::COM::AbstractInterface

Inherits:

Object

• Object
• VirtualBox::COM::AbstractInterface

show all

Defined in:

lib/virtualbox/com/abstract_interface.rb

Overview

class Time < AbstractInterface
  function :now, [[:out, :uint]]
  property :hour, :uint
end

# Assume `time` was retrieved already
puts time.foo.to_s
time.hour = 20
x = time.now

Instance Attribute Summary (collapse)

• - (Object) implementer readonly

  Returns the value of attribute implementer.

• - (Object) lib readonly

  Returns the value of attribute lib.

Class Method Summary (collapse)

• + (Object) function(name, type, spec, opts = {})

  Adds a function to the interface with the given name and function spec.

• + (Array) functions

  Returns the functions of the interface as an array in the order they were defined.

• + (Hash) member(name)

  Returns the information for a given member.

• + (Array) members

  Returns the members of the interface as an array.

• + (Array) properties

  Returns the properties of the interface as an array in the order they were defined.

• + (Object) property(name, type, opts = {})

  Adds a property to the interface with the given name, type, and options.

Instance Method Summary (collapse)

• - (Object) call_function(name, *args)

  Calls a function with the given name by calling call_function on the implementer.

• - (Boolean) has_function?(name)

  Returns a boolean if a given function exists or not.

• - (Boolean) has_property?(name)

  Returns a boolean if a given property exists or not.

• - (AbstractInterface) initialize(implementer, lib, *args) constructor

  Initializes the interface with the given implementer.

• - (Object) inspect

  Concise inspect.

• - (Object) member(name)

  Returns the member of the interface specified by name.

• - (Object) members

  Returns the members of the interface as an array.

• - (Object) read_property(name)

  Reads a property with the given name by calling the read_property method on the implementer.

• - (Object) write_property(name, value)

  Writes a property with the given name and value by calling the `write_property` method on the implementer.

112
113
114
115
116

# File 'lib/virtualbox/com/abstract_interface.rb', line 112

def initialize(implementer, lib, *args)
  # Instantiate the implementer and set it
  @lib = lib
  @implementer = implementer.new(self, lib, *args)
end

35
36
37

# File 'lib/virtualbox/com/abstract_interface.rb', line 35

def implementer
  @implementer
end

36
37
38

# File 'lib/virtualbox/com/abstract_interface.rb', line 36

def lib
  @lib
end

42
43
44
45
46
47
48
49
50
51
52

# File 'lib/virtualbox/com/abstract_interface.rb', line 42

def function(name, type, spec, opts={})
  members << [name, {
    :type => :function,
    :value_type => type,
    :spec => spec,
    :opts => opts
  }]

  # Define the method to call the function
  define_method(name) { |*args| call_function(name, *args) }
end

94
95
96
97
98

# File 'lib/virtualbox/com/abstract_interface.rb', line 94

def functions
  members.find_all do |data|
    data[1][:type] == :function
  end
end

73
74
75
76
77
78
79
80
81

# File 'lib/virtualbox/com/abstract_interface.rb', line 73

def member(name)
  members.each do |current_name, opts|
    if name == current_name
      return opts
    end
  end

  nil
end

86
87
88

# File 'lib/virtualbox/com/abstract_interface.rb', line 86

def members
  @members ||= []
end

104
105
106
107
108

# File 'lib/virtualbox/com/abstract_interface.rb', line 104

def properties
  members.find_all do |data|
    data[1][:type] == :property
  end
end

56
57
58
59
60
61
62
63
64
65
66
67
68

# File 'lib/virtualbox/com/abstract_interface.rb', line 56

def property(name, type, opts={})
  members << [name, {
    :type => :property,
    :value_type => type,
    :opts => opts
  }]

  # Define the method to read the property
  define_method(name) { read_property(name) }

  # Define method to write the property
  define_method("#{name}=".to_sym) { |value| write_property(name, value) } unless opts[:readonly]
end

133
134
135

# File 'lib/virtualbox/com/abstract_interface.rb', line 133

def call_function(name, *args)
  @implementer.call_function(name, args, member(name))
end

138
139
140
141

# File 'lib/virtualbox/com/abstract_interface.rb', line 138

def has_function?(name)
  info = member(name)
  !info.nil? && info[:type] == :function
end

144
145
146
147

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

def has_property?(name)
  info = member(name)
  !info.nil? && info[:type] == :property
end

162
163
164

# File 'lib/virtualbox/com/abstract_interface.rb', line 162

def inspect
  "#<#{self.class.name}>"
end

151
152
153

# File 'lib/virtualbox/com/abstract_interface.rb', line 151

def member(name)
  self.class.member(name)
end

157
158
159

# File 'lib/virtualbox/com/abstract_interface.rb', line 157

def members
  self.class.members
end

120
121
122
123

# File 'lib/virtualbox/com/abstract_interface.rb', line 120

def read_property(name)
  # Just call it on the implementer
  @implementer.read_property(name, member(name))
end

127
128
129

# File 'lib/virtualbox/com/abstract_interface.rb', line 127

def write_property(name, value)
  @implementer.write_property(name, value, member(name))
end