Class: VBox::Machine

Inherits:
Base
  • Object
show all
Defined in:
lib/virtualbox/classes/machine.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#_this, #delete!, #ensure_hash, #initialize, #vbox_class

Constructor Details

This class inherits a constructor from VBox::Base

Instance Attribute Details

#ref ⇒ Object (readonly)

Returns the value of attribute ref.



4
5
6
 
# File 'lib/virtualbox/classes/machine.rb', line 4

def ref
  @ref
end

Instance Method Details

#accelerate_2d_video_enabled ⇒ Object 



144
145
146
 
# File 'lib/virtualbox/classes/machine.rb', line 144

def accelerate_2d_video_enabled
  VBox::WebService.send_request(:i_machine_get_accelerate_2d_video_enabled, _this)
end

#accelerate_2d_video_enabled=(accelerate_2d_video_enabled) ⇒ Object 



148
149
150
151
 
# File 'lib/virtualbox/classes/machine.rb', line 148

def accelerate_2d_video_enabled=(accelerate_2d_video_enabled)
  VBox::WebService.send_request(:i_machine_set_accelerate_2d_video_enabled,
                                _this.merge(:accelerate_2d_video_enabled => accelerate_2d_video_enabled))
end

#accelerate_3d_enabled ⇒ Object 



135
136
137
 
# File 'lib/virtualbox/classes/machine.rb', line 135

def accelerate_3d_enabled
  VBox::WebService.send_request(:i_machine_get_accelerate_3d_enabled, _this)
end

#accelerate_3d_enabled=(accelerate_3d_enabled) ⇒ Object 



139
140
141
142
 
# File 'lib/virtualbox/classes/machine.rb', line 139

def accelerate_3d_enabled=(accelerate_3d_enabled)
  VBox::WebService.send_request(:i_machine_set_accelerate_3d_enabled,
                                _this.merge(:accelerate_3d_enabled => accelerate_3d_enabled))
end

#access_error ⇒ Object 



17
18
19
20
 
# File 'lib/virtualbox/classes/machine.rb', line 17

def access_error
  access_error = VBox::WebService.send_request(:i_machine_get_access_error, _this)
  VBox::VirtualBoxErrorInfo.new(access_error)
end

#accessible ⇒ Object 



13
14
15
 
# File 'lib/virtualbox/classes/machine.rb', line 13

def accessible
  VBox::WebService.send_request(:i_machine_get_accessible, _this)
end

#add_storage_controller(args = {}) ⇒ Object

Methods



550
551
552
553
554
 
# File 'lib/virtualbox/classes/machine.rb', line 550

def add_storage_controller(args={})
  ensure_hash(args)
  storage_controller = VBox::WebService.send_request(:i_machine_add_storage_controller, _this.merge(args))
  VBox::StorageController.new(storage_controller)
end

#allow_tracing_to_access_vm ⇒ Object 



514
515
516
 
# File 'lib/virtualbox/classes/machine.rb', line 514

def allow_tracing_to_access_vm
  VBox::WebService.send_request(:i_machine_get_allow_tracing_to_access_vm, _this)
end

#allow_tracing_to_access_vm=(allow_tracing_to_access_vm) ⇒ Object 



518
519
520
521
 
# File 'lib/virtualbox/classes/machine.rb', line 518

def allow_tracing_to_access_vm=(allow_tracing_to_access_vm)
  VBox::WebService.send_request(:i_machine_set_allow_tracing_to_access_vm,
                                _this.merge(:allow_tracing_to_access_vm => allow_tracing_to_access_vm))
end

#attach_device(args = {}) ⇒ Object 



556
557
558
559
560
 
# File 'lib/virtualbox/classes/machine.rb', line 556

def attach_device(args={})
  ensure_hash(args)
  args[:medium] = args[:medium].ref if args.has_key?(:medium) & args[:medium].respond_to?(:ref)
  VBox::WebService.send_request(:i_machine_attach_device, _this.merge(args))
end

#attach_device_without_medium(args = {}) ⇒ Object 



562
563
564
565
 
# File 'lib/virtualbox/classes/machine.rb', line 562

def attach_device_without_medium(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_attach_device_without_medium, _this.merge(args))
end

#attach_host_pci_device(args = {}) ⇒ Object 



567
568
569
570
 
# File 'lib/virtualbox/classes/machine.rb', line 567

def attach_host_pci_device(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_attach_host_pci_device, _this.merge(args))
end

#audio_adapter ⇒ Object 



289
290
291
292
 
# File 'lib/virtualbox/classes/machine.rb', line 289

def audio_adapter
  audio_adapter = VBox::WebService.send_request(:i_machine_get_audio_adapter, _this)
  VBox::AudioAdapter.new(audio_adapter)
end

#autostart_delay ⇒ Object 



532
533
534
 
# File 'lib/virtualbox/classes/machine.rb', line 532

def autostart_delay
  VBox::WebService.send_request(:i_machine_get_autostart_delay, _this)
end

#autostart_delay=(autostart_delay) ⇒ Object 



536
537
538
 
# File 'lib/virtualbox/classes/machine.rb', line 536

def autostart_delay=(autostart_delay)
  VBox::WebService.send_request(:i_machine_set_autostart_delay, _this.merge(:autostart_delay => autostart_delay))
end

#autostart_enabled ⇒ Object 



523
524
525
 
# File 'lib/virtualbox/classes/machine.rb', line 523

def autostart_enabled
  VBox::WebService.send_request(:i_machine_get_autostart_enabled, _this)
end

#autostart_enabled=(autostart_enabled) ⇒ Object 



527
528
529
530
 
# File 'lib/virtualbox/classes/machine.rb', line 527

def autostart_enabled=(autostart_enabled)
  VBox::WebService.send_request(:i_machine_set_autostart_enabled,
                                _this.merge(:autostart_enabled => autostart_enabled))
end

#autostop_type ⇒ Object 



540
541
542
 
# File 'lib/virtualbox/classes/machine.rb', line 540

def autostop_type
  VBox::WebService.send_request(:i_machine_get_autostop_type, _this)
end

#autostop_type=(autostop_type) ⇒ Object 



544
545
546
 
# File 'lib/virtualbox/classes/machine.rb', line 544

def autostop_type=(autostop_type)
  VBox::WebService.send_request(:i_machine_set_autostop_type, _this.merge(:autostop_type => autostop_type))
end

#bandwidth_control ⇒ Object 



493
494
495
496
 
# File 'lib/virtualbox/classes/machine.rb', line 493

def bandwidth_control
  bandwidth_control = VBox::WebService.send_request(:i_machine_get_bandwidth_control, _this)
  VBox::BandwidthControl.new(bandwidth_control)
end

#bios_settings ⇒ Object 



197
198
199
200
 
# File 'lib/virtualbox/classes/machine.rb', line 197

def bios_settings
  bios_settings = VBox::WebService.send_request(:i_machine_get_bios_settings, _this)
  VBox::BIOSSettings.new(bios_settings)
end

#can_show_console_window(args = {}) ⇒ Object 



572
573
574
575
 
# File 'lib/virtualbox/classes/machine.rb', line 572

def can_show_console_window(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_can_show_console_window, _this.merge(args))
end

#chipset_type ⇒ Object 



237
238
239
 
# File 'lib/virtualbox/classes/machine.rb', line 237

def chipset_type
  VBox::WebService.send_request(:i_machine_get_chipset_type, _this)
end

#chipset_type=(chipset_type) ⇒ Object 



241
242
243
 
# File 'lib/virtualbox/classes/machine.rb', line 241

def chipset_type=(chipset_type)
  VBox::WebService.send_request(:i_machine_set_chipset_type, _this.merge(:chipset_type => chipset_type))
end

#clipboard_mode ⇒ Object 



357
358
359
 
# File 'lib/virtualbox/classes/machine.rb', line 357

def clipboard_mode
  VBox::WebService.send_request(:i_machine_get_clipboard_mode, _this)
end

#clipboard_mode=(clipboard_mode) ⇒ Object 



361
362
363
 
# File 'lib/virtualbox/classes/machine.rb', line 361

def clipboard_mode=(clipboard_mode)
  VBox::WebService.send_request(:i_machine_set_clipboard_mode, _this.merge(:clipboard_mode => clipboard_mode))
end

#clone_to(args = {}) ⇒ Object 



577
578
579
580
581
582
 
# File 'lib/virtualbox/classes/machine.rb', line 577

def clone_to(args={})
  ensure_hash(args)
  args[:target] = args[:target].ref if args.has_key?(:target) & args[:target].respond_to?(:ref)
  progress = VBox::WebService.send_request(:i_machine_clone_to, _this.merge(args))
  VBox::Progress.new(progress)
end

#cpu_count ⇒ Object 



75
76
77
 
# File 'lib/virtualbox/classes/machine.rb', line 75

def cpu_count
  VBox::WebService.send_request(:i_machine_get_cpu_count, _this)
end

#cpu_count=(cpu_count) ⇒ Object 



79
80
81
 
# File 'lib/virtualbox/classes/machine.rb', line 79

def cpu_count=(cpu_count)
  VBox::WebService.send_request(:i_machine_set_cpu_count, _this.merge('CPUCount' => cpu_count))
end

#cpu_execution_cap ⇒ Object 



92
93
94
 
# File 'lib/virtualbox/classes/machine.rb', line 92

def cpu_execution_cap
  VBox::WebService.send_request(:i_machine_get_cpu_execution_cap, _this)
end

#cpu_execution_cap=(cpu_execution_cap) ⇒ Object 



96
97
98
99
 
# File 'lib/virtualbox/classes/machine.rb', line 96

def cpu_execution_cap=(cpu_execution_cap)
  VBox::WebService.send_request(:i_machine_set_cpu_execution_cap,
                                _this.merge('CPUExecutionCap' => cpu_execution_cap))
end

#cpu_hot_plug_enabled ⇒ Object 



83
84
85
 
# File 'lib/virtualbox/classes/machine.rb', line 83

def cpu_hot_plug_enabled
  VBox::WebService.send_request(:i_machine_get_cpu_hot_plug_enabled, _this)
end

#cpu_hot_plug_enabled=(cpu_hot_plug_enabled) ⇒ Object 



87
88
89
90
 
# File 'lib/virtualbox/classes/machine.rb', line 87

def cpu_hot_plug_enabled=(cpu_hot_plug_enabled)
  VBox::WebService.send_request(:i_machine_set_cpu_hot_plug_enabled,
                                _this.merge('CPUHotPlugEnabled' => cpu_hot_plug_enabled))
end

#create_shared_folder(args = {}) ⇒ Object 



584
585
586
587
 
# File 'lib/virtualbox/classes/machine.rb', line 584

def create_shared_folder(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_create_shared_folder, _this.merge(args))
end

#current_snapshot ⇒ Object 



337
338
339
340
 
# File 'lib/virtualbox/classes/machine.rb', line 337

def current_snapshot
  current_snapshot = VBox::WebService.send_request(:i_machine_get_current_snapshot, _this)
  VBox::Snapshot.new(current_snapshot)
end

#current_state_modified ⇒ Object 



346
347
348
 
# File 'lib/virtualbox/classes/machine.rb', line 346

def current_state_modified
  VBox::WebService.send_request(:i_machine_get_current_state_modified, _this)
end

#delete(args = {}) ⇒ Object 



589
590
591
592
593
594
595
596
597
598
 
# File 'lib/virtualbox/classes/machine.rb', line 589

def delete(args={})
  ensure_hash(args)
  if args.has_key?(:a_media)
    args[:a_media].map! do |a_medium|
      a_medium.respond_to?(:ref) ? a_medium.ref : a_medium
    end
  end
  progress = VBox::WebService.send_request(:i_machine_delete, _this.merge(args))
  VBox::Progress.new(progress)
end

#delete_guest_property(args = {}) ⇒ Object 



600
601
602
603
 
# File 'lib/virtualbox/classes/machine.rb', line 600

def delete_guest_property(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_delete_guest_property, _this.merge(args))
end

#description ⇒ Object 



30
31
32
 
# File 'lib/virtualbox/classes/machine.rb', line 30

def description
  VBox::WebService.send_request(:i_machine_get_description, _this)
end

#description=(description) ⇒ Object 



34
35
36
 
# File 'lib/virtualbox/classes/machine.rb', line 34

def description=(description)
  VBox::WebService.send_request(:i_machine_set_description, _this.merge(:description => description))
end

#detach_device(args = {}) ⇒ Object 



605
606
607
608
 
# File 'lib/virtualbox/classes/machine.rb', line 605

def detach_device(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_detach_device, _this.merge(args))
end

#detach_host_pci_device(args = {}) ⇒ Object 



610
611
612
613
 
# File 'lib/virtualbox/classes/machine.rb', line 610

def detach_host_pci_device(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_detach_host_pci_device, _this.merge(args))
end

#discard_settings(args = {}) ⇒ Object 



615
616
617
618
 
# File 'lib/virtualbox/classes/machine.rb', line 615

def discard_settings(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_discard_settings, _this.merge(args))
end

#drag_and_drop_mode ⇒ Object 



365
366
367
 
# File 'lib/virtualbox/classes/machine.rb', line 365

def drag_and_drop_mode
  VBox::WebService.send_request(:i_machine_get_drag_and_drop_mode, _this)
end

#drag_and_drop_mode=(drag_and_drop_mode) ⇒ Object 



369
370
371
372
 
# File 'lib/virtualbox/classes/machine.rb', line 369

def drag_and_drop_mode=(drag_and_drop_mode)
  VBox::WebService.send_request(:i_machine_set_drag_and_drop_mode,
                                _this.merge(:drag_and_drop_mode => drag_and_drop_mode))
end

#emaulated_usb_card_reader_enabled ⇒ Object 



267
268
269
 
# File 'lib/virtualbox/classes/machine.rb', line 267

def emaulated_usb_card_reader_enabled
  VBox::WebService.send_request(:i_machine_get_emaulated_usb_card_reader_enabled, _this)
end

#emaulated_usb_card_reader_enabled=(emaulated_usb_card_reader_enabled) ⇒ Object 



271
272
273
274
275
 
# File 'lib/virtualbox/classes/machine.rb', line 271

def emaulated_usb_card_reader_enabled=(emaulated_usb_card_reader_enabled)
  VBox::WebService.send_request(:i_machine_set_emaulated_usb_card_reader_enabled,
                                _this.merge(:emaulated_usb_card_reader_enabled =>
                                                emaulated_usb_card_reader_enabled))
end

#emaulated_usb_webcamera_enabled ⇒ Object 



258
259
260
 
# File 'lib/virtualbox/classes/machine.rb', line 258

def emaulated_usb_webcamera_enabled
  VBox::WebService.send_request(:i_machine_get_emaulated_usb_webcamera_enabled, _this)
end

#emaulated_usb_webcamera_enabled=(emaulated_usb_webcamera_enabled) ⇒ Object 



262
263
264
265
 
# File 'lib/virtualbox/classes/machine.rb', line 262

def emaulated_usb_webcamera_enabled=(emaulated_usb_webcamera_enabled)
  VBox::WebService.send_request(:i_machine_set_emaulated_usb_webcamera_enabled,
                                _this.merge(:emaulated_usb_webcamera_enabled => emaulated_usb_webcamera_enabled))
end

#enumerate_guest_properties(args = {}) ⇒ Object 



620
621
622
623
 
# File 'lib/virtualbox/classes/machine.rb', line 620

def enumerate_guest_properties(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_enumerate_guest_properties, _this.merge(args))
end

#export(args = {}) ⇒ Object 



625
626
627
628
629
630
 
# File 'lib/virtualbox/classes/machine.rb', line 625

def export(args={})
  ensure_hash(args)
  args[:a_appliance] = args[:a_appliance].ref if args.has_key?(:a_appliance) & args[:a_appliance].respond_to?(:ref)
  virtual_system_description = VBox::WebService.send_request(:i_machine_export, _this.merge(args))
  VBox::VirtualSystemDescription.new(virtual_system_description)
end

#fault_tolerance_address ⇒ Object 



438
439
440
 
# File 'lib/virtualbox/classes/machine.rb', line 438

def fault_tolerance_address
  VBox::WebService.send_request(:i_machine_get_fault_tolerance_address, _this)
end

#fault_tolerance_address=(fault_tolerance_address) ⇒ Object 



442
443
444
445
 
# File 'lib/virtualbox/classes/machine.rb', line 442

def fault_tolerance_address=(fault_tolerance_address)
  VBox::WebService.send_request(:i_machine_set_fault_tolerance_address,
                                _this.merge(:fault_tolerance_address => fault_tolerance_address))
end

#fault_tolerance_password ⇒ Object 



447
448
449
 
# File 'lib/virtualbox/classes/machine.rb', line 447

def fault_tolerance_password
  VBox::WebService.send_request(:i_machine_get_fault_tolerance_password, _this)
end

#fault_tolerance_password=(fault_tolerance_password) ⇒ Object 



451
452
453
454
 
# File 'lib/virtualbox/classes/machine.rb', line 451

def fault_tolerance_password=(fault_tolerance_password)
  VBox::WebService.send_request(:i_machine_set_fault_tolerance_password,
                                _this.merge(:fault_tolerance_password => fault_tolerance_password))
end

#fault_tolerance_port ⇒ Object 



429
430
431
 
# File 'lib/virtualbox/classes/machine.rb', line 429

def fault_tolerance_port
  VBox::WebService.send_request(:i_machine_get_fault_tolerance_port, _this)
end

#fault_tolerance_port=(fault_tolerance_port) ⇒ Object 



433
434
435
436
 
# File 'lib/virtualbox/classes/machine.rb', line 433

def fault_tolerance_port=(fault_tolerance_port)
  VBox::WebService.send_request(:i_machine_set_fault_tolerance_port,
                                _this.merge(:fault_tolerance_port => fault_tolerance_port))
end

#fault_tolerance_state ⇒ Object 



420
421
422
 
# File 'lib/virtualbox/classes/machine.rb', line 420

def fault_tolerance_state
  VBox::WebService.send_request(:i_machine_get_fault_tolerance_state, _this)
end

#fault_tolerance_state=(fault_tolerance_state) ⇒ Object 



424
425
426
427
 
# File 'lib/virtualbox/classes/machine.rb', line 424

def fault_tolerance_state=(fault_tolerance_state)
  VBox::WebService.send_request(:i_machine_set_fault_tolerance_state,
                                _this.merge(:fault_tolerance_state => fault_tolerance_state))
end

#fault_tolerance_sync_interval ⇒ Object 



456
457
458
 
# File 'lib/virtualbox/classes/machine.rb', line 456

def fault_tolerance_sync_interval
  VBox::WebService.send_request(:i_machine_get_fault_tolerance_sync_interval, _this)
end

#fault_tolerance_sync_interval=(fault_tolerance_sync_interval) ⇒ Object 



460
461
462
463
 
# File 'lib/virtualbox/classes/machine.rb', line 460

def fault_tolerance_sync_interval=(fault_tolerance_sync_interval)
  VBox::WebService.send_request(:i_machine_set_fault_tolerance_sync_interval,
                                _this.merge(:fault_tolerance_sync_interval => fault_tolerance_sync_interval))
end

#find_snapshot(args = {}) ⇒ Object 



632
633
634
635
636
 
# File 'lib/virtualbox/classes/machine.rb', line 632

def find_snapshot(args={})
  ensure_hash(args)
  snapshot = VBox::WebService.send_request(:i_machine_find_snapshot, _this.merge(args))
  VBox::Snapshot.new(snapshot)
end

#firmware_type ⇒ Object 



202
203
204
205
 
# File 'lib/virtualbox/classes/machine.rb', line 202

def firmware_type
  VBox::WebService.send_request(:i_machine_get_firmware_type, _this)

end

#firmware_type=(firmware_type) ⇒ Object 



207
208
209
 
# File 'lib/virtualbox/classes/machine.rb', line 207

def firmware_type=(firmware_type)
  VBox::WebService.send_request(:i_machine_set_firmware_type, _this.merge(:firmware_type => firmware_type))
end

#get_boot_order(args = {}) ⇒ Object 



638
639
640
641
 
# File 'lib/virtualbox/classes/machine.rb', line 638

def get_boot_order(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_boot_order, _this.merge(args))
end

#get_cpu_id_leaf(args = {}) ⇒ Object 



643
644
645
646
 
# File 'lib/virtualbox/classes/machine.rb', line 643

def get_cpu_id_leaf(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_cpu_id_leaf, _this.merge(args))
end

#get_cpu_property(args = {}) ⇒ Object 



648
649
650
651
 
# File 'lib/virtualbox/classes/machine.rb', line 648

def get_cpu_property(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_cpu_property, _this.merge(args))
end

#get_cpu_status(args = {}) ⇒ Object 



653
654
655
656
 
# File 'lib/virtualbox/classes/machine.rb', line 653

def get_cpu_status(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_cpu_status, _this.merge(args))
end

#get_extra_data(args = {}) ⇒ Object 



658
659
660
661
 
# File 'lib/virtualbox/classes/machine.rb', line 658

def get_extra_data(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_extra_data, _this.merge(args))
end

#get_extra_data_keys(args = {}) ⇒ Object 



663
664
665
666
 
# File 'lib/virtualbox/classes/machine.rb', line 663

def get_extra_data_keys(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_exrta_data_keys, _this.merge(args))
end

#get_guest_property(args = {}) ⇒ Object 



668
669
670
671
 
# File 'lib/virtualbox/classes/machine.rb', line 668

def get_guest_property(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_guest_property, _this.merge(args))
end

#get_guest_property_timestamp(args = {}) ⇒ Object 



673
674
675
676
 
# File 'lib/virtualbox/classes/machine.rb', line 673

def get_guest_property_timestamp(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_guest_property_timestamp, _this.merge(args))
end

#get_guest_property_value(args = {}) ⇒ Object 



678
679
680
681
 
# File 'lib/virtualbox/classes/machine.rb', line 678

def get_guest_property_value(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_guest_property_value, _this.merge(args))
end

#get_hw_virt_ex_property(args = {}) ⇒ Object 



683
684
685
686
 
# File 'lib/virtualbox/classes/machine.rb', line 683

def get_hw_virt_ex_property(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_get_hw_virt_ex_property, _this.merge(args))
end

#get_medium(args = {}) ⇒ Object 



688
689
690
691
692
 
# File 'lib/virtualbox/classes/machine.rb', line 688

def get_medium(args={})
  ensure_hash(args)
  medium = VBox::WebService.send_request(:i_machine_get_medium, _this.merge(args))
  VBox::Medium.new(medium)
end

#get_medium_attachment(args = {}) ⇒ Object 



694
695
696
697
698
 
# File 'lib/virtualbox/classes/machine.rb', line 694

def get_medium_attachment(args={})
  ensure_hash(args)
  medium_attachment = VBox::WebService.send_request(:i_machine_get_medium_attachment, _this.merge(args))
  VBox::Medium.new(medium_attachment)
end

#get_medium_attachments_of_controller(args = {}) ⇒ Object 



700
701
702
703
704
705
706
707
 
# File 'lib/virtualbox/classes/machine.rb', line 700

def get_medium_attachments_of_controller(args={})
  ensure_hash(args)
  medium_attachments_of_controller = VBox::WebService.send_request(:i_machine_get_medium_attachments_of_controller,
                                                                   _this.merge(args))
  medium_attachments_of_controller.to_a.map do |medium_attachment_of_controller|
    VBox::Medium.new(medium_attachment_of_controller)
  end
end

#get_network_adapter(args = {}) ⇒ Object 



709
710
711
712
713
 
# File 'lib/virtualbox/classes/machine.rb', line 709

def get_network_adapter(args={})
  ensure_hash(args)
  network_adapter = VBox::WebService.send_request(:i_machine_get_network_adapter, _this.merge(args))
  VBox::NetworkAdapter.new(network_adapter)
end

#get_parallel_port(args = {}) ⇒ Object 



715
716
717
718
719
 
# File 'lib/virtualbox/classes/machine.rb', line 715

def get_parallel_port(args={})
  ensure_hash(args)
  parallel_port = VBox::WebService.send_request(:i_machine_get_parallel_port, _this.merge(args))
  VBox::ParallelPort.new(parallel_port)
end

#get_serial_port(args = {}) ⇒ Object 



721
722
723
724
725
 
# File 'lib/virtualbox/classes/machine.rb', line 721

def get_serial_port(args={})
  ensure_hash(args)
  serial = VBox::WebService.send_request(:i_machine_get_serial_port, _this.merge(args))
  VBox::SerialPort.new(serial)
end

#get_storage_controller_by_instance(args = {}) ⇒ Object 



727
728
729
730
731
732
 
# File 'lib/virtualbox/classes/machine.rb', line 727

def get_storage_controller_by_instance(args={})
  ensure_hash(args)
  storage_controller = VBox::WebService.send_request(:i_machine_get_storage_controller_by_instance,
                                                     _this.merge(args))
  VBox::StorageController.new(storage_controller)
end

#get_storage_controller_by_name(args = {}) ⇒ Object 



734
735
736
737
738
 
# File 'lib/virtualbox/classes/machine.rb', line 734

def get_storage_controller_by_name(args={})
  ensure_hash(args)
  storage_controller = VBox::WebService.send_request(:i_machine_get_storage_controller_by_name, _this.merge(args))
  VBox::StorageController.new(storage_controller)
end

#groups ⇒ Object 



42
43
44
 
# File 'lib/virtualbox/classes/machine.rb', line 42

def groups
  VBox::WebService.send_request(:i_machine_get_groups, _this)
end

#groups=(groups) ⇒ Object 



46
47
48
 
# File 'lib/virtualbox/classes/machine.rb', line 46

def groups=(groups)
  VBox::WebService.send_request(:i_machine_set_groups, _this.merge(:groups => groups))
end

#guest_property_notification_patterns ⇒ Object 



374
375
376
 
# File 'lib/virtualbox/classes/machine.rb', line 374

def guest_property_notification_patterns
  VBox::WebService.send_request(:i_machine_get_guest_property_notification_patterns, _this)
end

#guest_property_notification_patterns=(guest_property_notification_patterns) ⇒ Object 



378
379
380
381
382
 
# File 'lib/virtualbox/classes/machine.rb', line 378

def guest_property_notification_patterns=(guest_property_notification_patterns)
  VBox::WebService.send_request(:i_machine_set_guest_property_notification_patterns,
                                _this.merge(:guest_property_notification_patterns =>
                                                guest_property_notification_patterns))
end

#hardware_uuid ⇒ Object 



67
68
69
 
# File 'lib/virtualbox/classes/machine.rb', line 67

def hardware_uuid
  VBox::WebService.send_request(:i_machine_get_hardware_uuid, _this)
end

#hardware_uuid=(hardware_uuid) ⇒ Object 



71
72
73
 
# File 'lib/virtualbox/classes/machine.rb', line 71

def hardware_uuid=(hardware_uuid)
  VBox::WebService.send_request(:i_machine_set_hardware_uuid, _this.merge(:hardware_uuid => hardware_uuid))
end

#hardware_version ⇒ Object 



58
59
60
 
# File 'lib/virtualbox/classes/machine.rb', line 58

def hardware_version
  VBox::WebService.send_request(:i_machine_get_hardware_version, _this)
end

#hardware_version=(hardware_version) ⇒ Object 



62
63
64
65
 
# File 'lib/virtualbox/classes/machine.rb', line 62

def hardware_version=(hardware_version)
  VBox::WebService.send_request(:i_machine_set_hardware_version,
                                _this.merge(:hardware_version => hardware_version))
end

#hot_plug_cpu(args = {}) ⇒ Object 



740
741
742
743
 
# File 'lib/virtualbox/classes/machine.rb', line 740

def hot_plug_cpu(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_hot_plug_cpu, _this.merge(args))
end

#hot_unplug_cpu(args = {}) ⇒ Object 



745
746
747
748
 
# File 'lib/virtualbox/classes/machine.rb', line 745

def hot_unplug_cpu(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_hot_unplug_cpu, _this.merge(args))
end

#hpet_enabled ⇒ Object 



229
230
231
 
# File 'lib/virtualbox/classes/machine.rb', line 229

def hpet_enabled
  VBox::WebService.send_request(:i_machine_get_hpet_enabled, _this)
end

#hpet_enabled=(hpet_enabled) ⇒ Object 



233
234
235
 
# File 'lib/virtualbox/classes/machine.rb', line 233

def hpet_enabled=(hpet_enabled)
  VBox::WebService.send_request(:i_machine_set_hpet_enabled, _this.merge('HPETEnabled' => hpet_enabled))
end

#id ⇒ Object 



38
39
40
 
# File 'lib/virtualbox/classes/machine.rb', line 38

def id
  VBox::WebService.send_request(:i_machine_get_id, _this)
end

#io_cache_enabled ⇒ Object 



473
474
475
 
# File 'lib/virtualbox/classes/machine.rb', line 473

def io_cache_enabled
  VBox::WebService.send_request(:i_machine_get_io_cache_enabled, _this)
end

#io_cache_enabled=(io_cache_enabled) ⇒ Object 



477
478
479
 
# File 'lib/virtualbox/classes/machine.rb', line 477

def io_cache_enabled=(io_cache_enabled)
  VBox::WebService.send_request(:i_machine_set_io_cache_enabled, _this.merge('IOCacheEnabled' => io_cache_enabled))
end

#io_cache_size ⇒ Object 



481
482
483
 
# File 'lib/virtualbox/classes/machine.rb', line 481

def io_cache_size
  VBox::WebService.send_request(:i_machine_get_io_cache_size, _this)
end

#io_cache_size=(io_cache_size) ⇒ Object 



485
486
487
 
# File 'lib/virtualbox/classes/machine.rb', line 485

def io_cache_size=(io_cache_size)
  VBox::WebService.send_request(:i_machine_set_io_cache_size, _this.merge('IOCacheSize' => io_cache_size))
end

#keyboard_hid_type ⇒ Object 



220
221
222
 
# File 'lib/virtualbox/classes/machine.rb', line 220

def keyboard_hid_type
  VBox::WebService.send_request(:i_machine_get_keyboard_hid_type, _this)
end

#keyboard_hid_type=(keyboard_hid_type) ⇒ Object 



224
225
226
227
 
# File 'lib/virtualbox/classes/machine.rb', line 224

def keyboard_hid_type=(keyboard_hid_type)
  VBox::WebService.send_request(:i_machine_set_keyboard_hid_type,
                                _this.merge(:keyboard_hid_type => keyboard_hid_type))
end

#last_state_change ⇒ Object 



325
326
327
 
# File 'lib/virtualbox/classes/machine.rb', line 325

def last_state_change
  VBox::WebService.send_request(:i_machine_get_last_state_change, _this)
end

#launch_vm_process(args = {}) ⇒ Object 



750
751
752
753
754
755
 
# File 'lib/virtualbox/classes/machine.rb', line 750

def launch_vm_process(args={})
  ensure_hash(args)
  args[:session] = args[:session].ref if args.has_key?(:session) & args[:session].respond_to?(:ref)
  progress = VBox::WebService.send_request(:i_machine_launch_vm_process, _this.merge(args))
  VBox::Progress.new(progress)
end

#lock_machine(args = {}) ⇒ Object 



757
758
759
760
761
 
# File 'lib/virtualbox/classes/machine.rb', line 757

def lock_machine(args={})
  ensure_hash(args)
  args[:session] = args[:session].ref if args.has_key?(:session) & args[:session].respond_to?(:ref)
  VBox::WebService.send_request(:i_machine_lock_machine, _this.merge(args))
end

#log_folder ⇒ Object 



333
334
335
 
# File 'lib/virtualbox/classes/machine.rb', line 333

def log_folder
  VBox::WebService.send_request(:i_machine_get_log_folder, _this)
end

#medium_attachments ⇒ Object 



277
278
279
280
281
282
 
# File 'lib/virtualbox/classes/machine.rb', line 277

def medium_attachments
  medium_attachments = VBox::WebService.send_request(:i_machine_get_medium_attachments, _this)
  medium_attachments.to_a.map do |medium_attachment|
    VBox::MediumAttachment.new(medium_attachment)
  end
end

#memory_balloon_size ⇒ Object 



109
110
111
 
# File 'lib/virtualbox/classes/machine.rb', line 109

def memory_balloon_size
  VBox::WebService.send_request(:i_machine_get_memory_balloon_size, _this)
end

#memory_balloon_size=(memory_balloon_size) ⇒ Object 



113
114
115
116
 
# File 'lib/virtualbox/classes/machine.rb', line 113

def memory_balloon_size=(memory_balloon_size)
  VBox::WebService.send_request(:i_machine_set_memory_balloon_size,
                                _this.merge(:memory_balloon_size => memory_balloon_size))
end

#memory_size ⇒ Object 



101
102
103
 
# File 'lib/virtualbox/classes/machine.rb', line 101

def memory_size
  VBox::WebService.send_request(:i_machine_get_memory_size, _this)
end

#memory_size=(memory_size) ⇒ Object 



105
106
107
 
# File 'lib/virtualbox/classes/machine.rb', line 105

def memory_size=(memory_size)
  VBox::WebService.send_request(:i_machine_set_memory_size, _this.merge(:memory_size => memory_size))
end

#monitor_count ⇒ Object 



153
154
155
 
# File 'lib/virtualbox/classes/machine.rb', line 153

def monitor_count
  VBox::WebService.send_request(:i_machine_get_monitor_count, _this)
end

#monitor_count=(monitor_count) ⇒ Object 



157
158
159
 
# File 'lib/virtualbox/classes/machine.rb', line 157

def monitor_count=(monitor_count)
  VBox::WebService.send_request(:i_machine_set_monitor_count, _this.merge(:monitor_count => monitor_count))
end

#mount_medium(args = {}) ⇒ Object 



763
764
765
766
767
 
# File 'lib/virtualbox/classes/machine.rb', line 763

def mount_medium(args={})
  ensure_hash(args)
  args[:medium] = args[:medium].ref if args.has_key?(:medium) & args[:medium].respond_to?(:ref)
  VBox::WebService.send_request(:i_machine_mount_medium, _this.merge(args))
end

#name ⇒ Object 



22
23
24
 
# File 'lib/virtualbox/classes/machine.rb', line 22

def name
  VBox::WebService.send_request(:i_machine_get_name, _this)
end

#name=(name) ⇒ Object 



26
27
28
 
# File 'lib/virtualbox/classes/machine.rb', line 26

def name=(name)
  VBox::WebService.send_request(:i_machine_set_name, _this.merge(:name => name))
end

#non_rotational_device(args = {}) ⇒ Object 



769
770
771
772
 
# File 'lib/virtualbox/classes/machine.rb', line 769

def non_rotational_device(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_non_rotational_device, _this.merge(args))
end

#os_type_id ⇒ Object 



50
51
52
 
# File 'lib/virtualbox/classes/machine.rb', line 50

def os_type_id
  VBox::WebService.send_request(:i_machine_get_os_type_id, _this)
end

#os_type_id=(os_type_id) ⇒ Object 



54
55
56
 
# File 'lib/virtualbox/classes/machine.rb', line 54

def os_type_id=(os_type_id)
  VBox::WebService.send_request(:i_machine_set_os_type_id, _this.merge('OSTypeId' => os_type_id))
end

#page_fusion_enabled ⇒ Object 



118
119
120
 
# File 'lib/virtualbox/classes/machine.rb', line 118

def page_fusion_enabled
  VBox::WebService.send_request(:i_machine_get_page_fusion_enabled, _this)
end

#page_fusion_enabled=(page_fusion_enabled) ⇒ Object 



122
123
124
125
 
# File 'lib/virtualbox/classes/machine.rb', line 122

def page_fusion_enabled=(page_fusion_enabled)
  VBox::WebService.send_request(:i_machine_set_page_fusion_enabled,
                                _this.merge(:page_fusion_enabled => page_fusion_enabled))
end

#parent ⇒ Object

Attributes



8
9
10
11
 
# File 'lib/virtualbox/classes/machine.rb', line 8

def parent
  parent = VBox::WebService.send_request(:i_machine_get_parent, _this)
  VBox::Machine.new(parent)
end

#passthrough_device(args = {}) ⇒ Object 



774
775
776
777
 
# File 'lib/virtualbox/classes/machine.rb', line 774

def passthrough_device(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_passthrough_device, _this.merge(args))
end

#pci_device_assignments ⇒ Object 



489
490
491
 
# File 'lib/virtualbox/classes/machine.rb', line 489

def pci_device_assignments
  VBox::WebService.send_request(:i_machine_get_pci_device_assignments, _this)
end

#pointing_hid_type ⇒ Object 



211
212
213
 
# File 'lib/virtualbox/classes/machine.rb', line 211

def pointing_hid_type
  VBox::WebService.send_request(:i_machine_get_pointing_hid_type, _this)
end

#pointing_hid_type=(pointing_hid_type) ⇒ Object 



215
216
217
218
 
# File 'lib/virtualbox/classes/machine.rb', line 215

def pointing_hid_type=(pointing_hid_type)
  VBox::WebService.send_request(:i_machine_set_pointing_hid_type,
                                _this.merge(:pointing_hid_type => pointing_hid_type))
end

#query_log_filename(args = {}) ⇒ Object 



779
780
781
782
 
# File 'lib/virtualbox/classes/machine.rb', line 779

def query_log_filename(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_query_log_filename, _this.merge(args))
end

#query_saved_guest_screen_info(args = {}) ⇒ Object 



784
785
786
787
 
# File 'lib/virtualbox/classes/machine.rb', line 784

def query_saved_guest_screen_info(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_query_saved_guest_screen_info, _this.merge(args))
end

#query_saved_screenshot_png_size(args = {}) ⇒ Object 



789
790
791
792
 
# File 'lib/virtualbox/classes/machine.rb', line 789

def query_saved_screenshot_png_size(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_query_saved_screenshot_png_size, _this.merge(args))
end

#query_saved_thumbnail_size(args = {}) ⇒ Object 



794
795
796
797
 
# File 'lib/virtualbox/classes/machine.rb', line 794

def query_saved_thumbnail_size(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_query_saved_thumbnail_size, _this.merge(args))
end

#read_log(args = {}) ⇒ Object 



799
800
801
802
 
# File 'lib/virtualbox/classes/machine.rb', line 799

def read_log(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_read_log, _this.merge(args))
end

#read_saved_screenshot_png_to_array(args = {}) ⇒ Object 



804
805
806
807
 
# File 'lib/virtualbox/classes/machine.rb', line 804

def read_saved_screenshot_png_to_array(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_read_saved_screenshot_png_to_array, _this.merge(args))
end

#read_saved_thumbnail_png_to_array(args = {}) ⇒ Object 



809
810
811
812
 
# File 'lib/virtualbox/classes/machine.rb', line 809

def read_saved_thumbnail_png_to_array(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_read_saved_thumbnail_png_to_array, _this.merge(args))
end

#read_saved_thumbnail_to_array(args = {}) ⇒ Object 



814
815
816
817
 
# File 'lib/virtualbox/classes/machine.rb', line 814

def read_saved_thumbnail_to_array(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_read_saved_thumbnail_to_array, _this.merge(args))
end

#remove_all_cpuid_leaves ⇒ Object 



819
820
821
 
# File 'lib/virtualbox/classes/machine.rb', line 819

def remove_all_cpuid_leaves
  VBox::WebService.send_request(:i_machine_remove_all_cpuid_leaves, _this)
end

#remove_cpuid_leaf(args = {}) ⇒ Object 



823
824
825
826
 
# File 'lib/virtualbox/classes/machine.rb', line 823

def remove_cpuid_leaf(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_remove_cpuid_leaf, _this.merge(args))
end

#remove_shared_folder(args = {}) ⇒ Object 



828
829
830
831
 
# File 'lib/virtualbox/classes/machine.rb', line 828

def remove_shared_folder(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_remove_shared_folder, _this.merge(args))
end

#remove_storage_controller(args = {}) ⇒ Object 



833
834
835
836
 
# File 'lib/virtualbox/classes/machine.rb', line 833

def remove_storage_controller(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_remove_storage_controller, _this.merge(args))
end

#rtc_use_utc ⇒ Object 



465
466
467
 
# File 'lib/virtualbox/classes/machine.rb', line 465

def rtc_use_utc
  VBox::WebService.send_request(:i_machine_get_rtc_use_utc, _this)
end

#rtc_use_utc=(rtc_use_utc) ⇒ Object 



469
470
471
 
# File 'lib/virtualbox/classes/machine.rb', line 469

def rtc_use_utc=(rtc_use_utc)
  VBox::WebService.send_request(:i_machine_set_rtc_use_utc, _this.merge('RTCUseUTC' => rtc_use_utc))
end

#save_settings ⇒ Object 



838
839
840
 
# File 'lib/virtualbox/classes/machine.rb', line 838

def save_settings
  VBox::WebService.send_request(:i_machine_save_settings, _this)
end

#session_pid ⇒ Object 



317
318
319
 
# File 'lib/virtualbox/classes/machine.rb', line 317

def session_pid
  VBox::WebService.send_request(:i_machine_get_session_pid, _this)
end

#session_state ⇒ Object 



309
310
311
 
# File 'lib/virtualbox/classes/machine.rb', line 309

def session_state
  VBox::WebService.send_request(:i_machine_get_session_state, _this)
end

#session_type ⇒ Object 



313
314
315
 
# File 'lib/virtualbox/classes/machine.rb', line 313

def session_type
  VBox::WebService.send_request(:i_machine_get_session_type, _this)
end

#set_auto_discard_for_device(args = {}) ⇒ Object 



842
843
844
845
 
# File 'lib/virtualbox/classes/machine.rb', line 842

def set_auto_discard_for_device(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_auto_discard_for_device, _this.merge(args))
end

#set_bandwidth_group_for_device(args = {}) ⇒ Object 



847
848
849
850
851
852
853
 
# File 'lib/virtualbox/classes/machine.rb', line 847

def set_bandwidth_group_for_device(args={})
  ensure_hash(args)
  if args.has_key?(:bandwidth_group) & args[:bandwidth_group].respond_to?(:ref)
    args[:bandwidth_group] = args[:bandwidth_group].ref
  end
  VBox::WebService.send_request(:i_machine_set_bandwidth_group_for_device, _this.merge(args))
end

#set_boot_order(args = {}) ⇒ Object 



855
856
857
858
 
# File 'lib/virtualbox/classes/machine.rb', line 855

def set_boot_order(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_boot_order, _this.merge(args))
end

#set_cpu_property(args = {}) ⇒ Object 



865
866
867
868
 
# File 'lib/virtualbox/classes/machine.rb', line 865

def set_cpu_property(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_cpu_property, _this.merge(args))
end

#set_cpuid_leaf(args = {}) ⇒ Object 



860
861
862
863
 
# File 'lib/virtualbox/classes/machine.rb', line 860

def set_cpuid_leaf(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_cpuid_leaf, _this.merge(args))
end

#set_extra_data(args = {}) ⇒ Object 



870
871
872
873
 
# File 'lib/virtualbox/classes/machine.rb', line 870

def set_extra_data(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_extra_data, _this.merge(args))
end

#set_guest_property(args = {}) ⇒ Object 



875
876
877
878
 
# File 'lib/virtualbox/classes/machine.rb', line 875

def set_guest_property(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_guest_property, _this.merge(args))
end

#set_guest_property_value(args = {}) ⇒ Object 



880
881
882
883
 
# File 'lib/virtualbox/classes/machine.rb', line 880

def set_guest_property_value(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_guest_property_value, _this.merge(args))
end

#set_hw_virt_ex_property(args = {}) ⇒ Object 



885
886
887
888
 
# File 'lib/virtualbox/classes/machine.rb', line 885

def set_hw_virt_ex_property(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_hw_virt_ex_property, _this.merge(args))
end

#set_no_bandwidth_group_for_device(args = {}) ⇒ Object 



890
891
892
893
 
# File 'lib/virtualbox/classes/machine.rb', line 890

def set_no_bandwidth_group_for_device(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_no_bandwidth_group_for_device, _this.merge(args))
end

#set_storage_controller_bootable(args = {}) ⇒ Object 



895
896
897
898
 
# File 'lib/virtualbox/classes/machine.rb', line 895

def set_storage_controller_bootable(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_set_storage_controller_bootable, _this.merge(args))
end

#settings_file_path ⇒ Object 



301
302
303
 
# File 'lib/virtualbox/classes/machine.rb', line 301

def settings_file_path
  VBox::WebService.send_request(:i_machine_get_settings_file_path, _this)
end

#settings_modified ⇒ Object 



305
306
307
 
# File 'lib/virtualbox/classes/machine.rb', line 305

def settings_modified
  VBox::WebService.send_request(:i_machine_get_settings_modified, _this)
end

#shared_folders ⇒ Object 



350
351
352
353
354
355
 
# File 'lib/virtualbox/classes/machine.rb', line 350

def shared_folders
  shared_folders = VBox::WebService.send_request(:i_machine_get_shared_folders, _this)
  shared_folders.to_a.map do |shared_folder|
    VBox::SharedFolder.new(shared_folder)
  end
end

#show_console_window ⇒ Object 



900
901
902
 
# File 'lib/virtualbox/classes/machine.rb', line 900

def show_console_window
  VBox::WebService.send_request(:i_machine_show_console_window, _this.merge)
end

#snapshot_count ⇒ Object 



342
343
344
 
# File 'lib/virtualbox/classes/machine.rb', line 342

def snapshot_count
  VBox::WebService.send_request(:i_machine_get_snapshot_count, _this)
end

#snapshot_folder ⇒ Object 



245
246
247
 
# File 'lib/virtualbox/classes/machine.rb', line 245

def snapshot_folder
  VBox::WebService.send_request(:i_machine_get_snapshot_folder, _this)
end

#snapshot_folder=(snapshot_folder) ⇒ Object 



249
250
251
 
# File 'lib/virtualbox/classes/machine.rb', line 249

def snapshot_folder=(snapshot_folder)
  VBox::WebService.send_request(:i_machine_set_snapshot_folder, _this.merge(:snapshot_folder => snapshot_folder))
end

#state ⇒ Object 



321
322
323
 
# File 'lib/virtualbox/classes/machine.rb', line 321

def state
  VBox::WebService.send_request(:i_machine_get_state, _this)
end

#state_file_path ⇒ Object 



329
330
331
 
# File 'lib/virtualbox/classes/machine.rb', line 329

def state_file_path
  VBox::WebService.send_request(:i_machine_get_state_file_path, _this)
end

#storage_controllers ⇒ Object 



294
295
296
297
298
299
 
# File 'lib/virtualbox/classes/machine.rb', line 294

def storage_controllers
  storage_controllers = VBox::WebService.send_request(:i_machine_get_storage_controllers, _this)
  storage_controllers.to_a.map do |storage_controller|
    VBox::StorageController.new(storage_controller)
  end
end

#teleporter_address ⇒ Object 



402
403
404
 
# File 'lib/virtualbox/classes/machine.rb', line 402

def teleporter_address
  VBox::WebService.send_request(:i_machine_get_teleporter_address, _this)
end

#teleporter_address=(teleporter_address) ⇒ Object 



406
407
408
409
 
# File 'lib/virtualbox/classes/machine.rb', line 406

def teleporter_address=(teleporter_address)
  VBox::WebService.send_request(:i_machine_set_teleporter_address,
                                _this.merge(:teleporter_address => teleporter_address))
end

#teleporter_enabled ⇒ Object 



384
385
386
 
# File 'lib/virtualbox/classes/machine.rb', line 384

def teleporter_enabled
  VBox::WebService.send_request(:i_machine_get_teleporter_enabled, _this)
end

#teleporter_enabled=(teleporter_enabled) ⇒ Object 



388
389
390
391
 
# File 'lib/virtualbox/classes/machine.rb', line 388

def teleporter_enabled=(teleporter_enabled)
  VBox::WebService.send_request(:i_machine_set_teleporter_enabled,
                                _this.merge(:teleporter_enabled => teleporter_enabled))
end

#teleporter_password ⇒ Object 



411
412
413
 
# File 'lib/virtualbox/classes/machine.rb', line 411

def teleporter_password
  VBox::WebService.send_request(:i_machine_get_teleporter_password, _this)
end

#teleporter_password=(teleporter_password) ⇒ Object 



415
416
417
418
 
# File 'lib/virtualbox/classes/machine.rb', line 415

def teleporter_password=(teleporter_password)
  VBox::WebService.send_request(:i_machine_set_teleporter_password,
                                _this.merge(:teleporter_password => teleporter_password))
end

#teleporter_port ⇒ Object 



393
394
395
 
# File 'lib/virtualbox/classes/machine.rb', line 393

def teleporter_port
  VBox::WebService.send_request(:i_machine_get_teleporter_port, _this)
end

#teleporter_port=(teleporter_port) ⇒ Object 



397
398
399
400
 
# File 'lib/virtualbox/classes/machine.rb', line 397

def teleporter_port=(teleporter_port)
  VBox::WebService.send_request(:i_machine_set_teleporter_port,
                                _this.merge(:teleporter_port => teleporter_port))
end

#temporary_eject_device(args = {}) ⇒ Object 



904
905
906
907
 
# File 'lib/virtualbox/classes/machine.rb', line 904

def temporary_eject_device(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_temporary_eject_device, _this.merge(args))
end

#tracing_config ⇒ Object 



506
507
508
 
# File 'lib/virtualbox/classes/machine.rb', line 506

def tracing_config
  VBox::WebService.send_request(:i_machine_get_tracing_config, _this)
end

#tracing_config=(tracing_config) ⇒ Object 



510
511
512
 
# File 'lib/virtualbox/classes/machine.rb', line 510

def tracing_config=(tracing_config)
  VBox::WebService.send_request(:i_machine_set_tracing_config, _this.merge(:tracing_config => tracing_config))
end

#tracing_enabled ⇒ Object 



498
499
500
 
# File 'lib/virtualbox/classes/machine.rb', line 498

def tracing_enabled
  VBox::WebService.send_request(:i_machine_get_tracing_enabled, _this)
end

#tracing_enabled=(tracing_enabled) ⇒ Object 



502
503
504
 
# File 'lib/virtualbox/classes/machine.rb', line 502

def tracing_enabled=(tracing_enabled)
  VBox::WebService.send_request(:i_machine_set_tracing_enabled, _this.merge(:tracing_enabled => tracing_enabled))
end

#umnount_medium(args = {}) ⇒ Object 



909
910
911
912
 
# File 'lib/virtualbox/classes/machine.rb', line 909

def umnount_medium(args={})
  ensure_hash(args)
  VBox::WebService.send_request(:i_machine_umount_medium, _this.merge(args))
end

#unregister(args = {}) ⇒ Object 



914
915
916
917
918
919
920
 
# File 'lib/virtualbox/classes/machine.rb', line 914

def unregister(args={})
  ensure_hash(args)
  media = VBox::WebService.send_request(:i_machine_unregister, _this.merge(args))
  media.to_a.map do |medium|
    VBox::Medium.new(medium)
  end
end

#usb_controller ⇒ Object 



284
285
286
287
 
# File 'lib/virtualbox/classes/machine.rb', line 284

def usb_controller
  usb_controller = VBox::WebService.send_request(:i_machine_get_usb_controller, _this)
  VBox::USBController.new(usb_controller)
end

#video_capture_enabled ⇒ Object 



161
162
163
 
# File 'lib/virtualbox/classes/machine.rb', line 161

def video_capture_enabled
  VBox::WebService.send_request(:i_machine_get_video_capture_enabled, _this)
end

#video_capture_enabled=(video_capture_enabled) ⇒ Object 



165
166
167
168
 
# File 'lib/virtualbox/classes/machine.rb', line 165

def video_capture_enabled=(video_capture_enabled)
  VBox::WebService.send_request(:i_machine_set_video_capture_enabled,
                                _this.merge('VideoCaptureEnabled' => video_capture_enabled))
end

#video_capture_file ⇒ Object 



170
171
172
 
# File 'lib/virtualbox/classes/machine.rb', line 170

def video_capture_file
  VBox::WebService.send_request(:i_machine_get_video_capture_file, _this)
end

#video_capture_file=(video_capture_file) ⇒ Object 



174
175
176
177
 
# File 'lib/virtualbox/classes/machine.rb', line 174

def video_capture_file=(video_capture_file)
  VBox::WebService.send_request(:i_machine_set_video_capture_file,
                                _this.merge('VideoCaptureFile' => video_capture_file))
end

#video_capture_height ⇒ Object 



188
189
190
 
# File 'lib/virtualbox/classes/machine.rb', line 188

def video_capture_height
  VBox::WebService.send_request(:i_machine_get_video_capture_height, _this)
end

#video_capture_height=(video_capture_height) ⇒ Object 



192
193
194
195
 
# File 'lib/virtualbox/classes/machine.rb', line 192

def video_capture_height=(video_capture_height)
  VBox::WebService.send_request(:i_machine_set_video_capture_height,
                                _this.merge('VideoCaptureHeight' => video_capture_height))
end

#video_capture_width ⇒ Object 



179
180
181
 
# File 'lib/virtualbox/classes/machine.rb', line 179

def video_capture_width
  VBox::WebService.send_request(:i_machine_get_video_capture_width, _this)
end

#video_capture_width=(video_capture_width) ⇒ Object 



183
184
185
186
 
# File 'lib/virtualbox/classes/machine.rb', line 183

def video_capture_width=(video_capture_width)
  VBox::WebService.send_request(:i_machine_set_video_capture_width,
                                _this.merge('VideoCaptureWidth' => video_capture_width))
end

#vram_size ⇒ Object 



127
128
129
 
# File 'lib/virtualbox/classes/machine.rb', line 127

def vram_size
  VBox::WebService.send_request(:i_machine_get_vram_size, _this)
end

#vram_size=(vram_size) ⇒ Object 



131
132
133
 
# File 'lib/virtualbox/classes/machine.rb', line 131

def vram_size=(vram_size)
  VBox::WebService.send_request(:i_machine_set_vram_size, _this.merge('VRAMSize' => vram_size))
end

#vrde_server ⇒ Object 



253
254
255
256
 
# File 'lib/virtualbox/classes/machine.rb', line 253

def vrde_server
  vrde_server = VBox::WebService.send_request(:i_machine_get_vrde_server, _this)
  VBox::VRDEServer.new(vrde_server)
end