/// <summary>
/// Creates a new Subject from a Hashtable.
/// </summary>
/// <param name="table"></param>
public Subject(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
subject_identifier = Marshalling.ParseString(table, "subject_identifier");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
roles = Marshalling.ParseSetRef <Role>(table, "roles");
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this USB_group
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("name_label"))
{
name_label = Marshalling.ParseString(table, "name_label");
}
if (table.ContainsKey("name_description"))
{
name_description = Marshalling.ParseString(table, "name_description");
}
if (table.ContainsKey("PUSBs"))
{
PUSBs = Marshalling.ParseSetRef <PUSB>(table, "PUSBs");
}
if (table.ContainsKey("VUSBs"))
{
VUSBs = Marshalling.ParseSetRef <VUSB>(table, "VUSBs");
}
if (table.ContainsKey("other_config"))
{
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this VM_appliance
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("name_label"))
{
name_label = Marshalling.ParseString(table, "name_label");
}
if (table.ContainsKey("name_description"))
{
name_description = Marshalling.ParseString(table, "name_description");
}
if (table.ContainsKey("allowed_operations"))
{
allowed_operations = Helper.StringArrayToEnumList <vm_appliance_operation>(Marshalling.ParseStringArray(table, "allowed_operations"));
}
if (table.ContainsKey("current_operations"))
{
current_operations = Maps.convert_from_proxy_string_vm_appliance_operation(Marshalling.ParseHashTable(table, "current_operations"));
}
if (table.ContainsKey("VMs"))
{
VMs = Marshalling.ParseSetRef <VM>(table, "VMs");
}
}
/// <summary>
/// Creates a new Role from a Hashtable.
/// </summary>
/// <param name="table"></param>
public Role(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
subroles = Marshalling.ParseSetRef <Role>(table, "subroles");
}
/// <summary>
/// Creates a new PIF from a Hashtable.
/// </summary>
/// <param name="table"></param>
public PIF(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
device = Marshalling.ParseString(table, "device");
network = Marshalling.ParseRef <Network>(table, "network");
host = Marshalling.ParseRef <Host>(table, "host");
MAC = Marshalling.ParseString(table, "MAC");
MTU = Marshalling.ParseLong(table, "MTU");
VLAN = Marshalling.ParseLong(table, "VLAN");
metrics = Marshalling.ParseRef <PIF_metrics>(table, "metrics");
physical = Marshalling.ParseBool(table, "physical");
currently_attached = Marshalling.ParseBool(table, "currently_attached");
ip_configuration_mode = (ip_configuration_mode)Helper.EnumParseDefault(typeof(ip_configuration_mode), Marshalling.ParseString(table, "ip_configuration_mode"));
IP = Marshalling.ParseString(table, "IP");
netmask = Marshalling.ParseString(table, "netmask");
gateway = Marshalling.ParseString(table, "gateway");
DNS = Marshalling.ParseString(table, "DNS");
bond_slave_of = Marshalling.ParseRef <Bond>(table, "bond_slave_of");
bond_master_of = Marshalling.ParseSetRef <Bond>(table, "bond_master_of");
VLAN_master_of = Marshalling.ParseRef <VLAN>(table, "VLAN_master_of");
VLAN_slave_of = Marshalling.ParseSetRef <VLAN>(table, "VLAN_slave_of");
management = Marshalling.ParseBool(table, "management");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
disallow_unplug = Marshalling.ParseBool(table, "disallow_unplug");
tunnel_access_PIF_of = Marshalling.ParseSetRef <Tunnel>(table, "tunnel_access_PIF_of");
tunnel_transport_PIF_of = Marshalling.ParseSetRef <Tunnel>(table, "tunnel_transport_PIF_of");
ipv6_configuration_mode = (ipv6_configuration_mode)Helper.EnumParseDefault(typeof(ipv6_configuration_mode), Marshalling.ParseString(table, "ipv6_configuration_mode"));
IPv6 = Marshalling.ParseStringArray(table, "IPv6");
ipv6_gateway = Marshalling.ParseString(table, "ipv6_gateway");
primary_address_type = (primary_address_type)Helper.EnumParseDefault(typeof(primary_address_type), Marshalling.ParseString(table, "primary_address_type"));
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this Bond
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("master"))
{
master = Marshalling.ParseRef <PIF>(table, "master");
}
if (table.ContainsKey("slaves"))
{
slaves = Marshalling.ParseSetRef <PIF>(table, "slaves");
}
if (table.ContainsKey("other_config"))
{
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
if (table.ContainsKey("primary_slave"))
{
primary_slave = Marshalling.ParseRef <PIF>(table, "primary_slave");
}
if (table.ContainsKey("mode"))
{
mode = (bond_mode)Helper.EnumParseDefault(typeof(bond_mode), Marshalling.ParseString(table, "mode"));
}
if (table.ContainsKey("properties"))
{
properties = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "properties"));
}
if (table.ContainsKey("links_up"))
{
links_up = Marshalling.ParseLong(table, "links_up");
}
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this PVS_site
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("name_label"))
{
name_label = Marshalling.ParseString(table, "name_label");
}
if (table.ContainsKey("name_description"))
{
name_description = Marshalling.ParseString(table, "name_description");
}
if (table.ContainsKey("PVS_uuid"))
{
PVS_uuid = Marshalling.ParseString(table, "PVS_uuid");
}
if (table.ContainsKey("cache_storage"))
{
cache_storage = Marshalling.ParseSetRef <PVS_cache_storage>(table, "cache_storage");
}
if (table.ContainsKey("servers"))
{
servers = Marshalling.ParseSetRef <PVS_server>(table, "servers");
}
if (table.ContainsKey("proxies"))
{
proxies = Marshalling.ParseSetRef <PVS_proxy>(table, "proxies");
}
}
/// <summary>
/// Creates a new USB_group from a Hashtable.
/// </summary>
/// <param name="table"></param>
public USB_group(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
PUSBs = Marshalling.ParseSetRef <PUSB>(table, "PUSBs");
VUSBs = Marshalling.ParseSetRef <VUSB>(table, "VUSBs");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
/// <summary>
/// Creates a new VM_appliance from a Hashtable.
/// </summary>
/// <param name="table"></param>
public VM_appliance(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
allowed_operations = Helper.StringArrayToEnumList <vm_appliance_operation>(Marshalling.ParseStringArray(table, "allowed_operations"));
current_operations = Maps.convert_from_proxy_string_vm_appliance_operation(Marshalling.ParseHashTable(table, "current_operations"));
VMs = Marshalling.ParseSetRef <VM>(table, "VMs");
}
/// <summary>
/// Creates a new GPU_group from a Hashtable.
/// </summary>
/// <param name="table"></param>
public GPU_group(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
PGPUs = Marshalling.ParseSetRef <PGPU>(table, "PGPUs");
VGPUs = Marshalling.ParseSetRef <VGPU>(table, "VGPUs");
GPU_types = Marshalling.ParseStringArray(table, "GPU_types");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
/// <summary>
/// Creates a new PVS_site from a Hashtable.
/// </summary>
/// <param name="table"></param>
public PVS_site(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
PVS_uuid = Marshalling.ParseString(table, "PVS_uuid");
cache_storage = Marshalling.ParseSetRef <PVS_cache_storage>(table, "cache_storage");
servers = Marshalling.ParseSetRef <PVS_server>(table, "servers");
proxies = Marshalling.ParseSetRef <PVS_proxy>(table, "proxies");
}
/// <summary>
/// Creates a new Bond from a Hashtable.
/// </summary>
/// <param name="table"></param>
public Bond(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
master = Marshalling.ParseRef <PIF>(table, "master");
slaves = Marshalling.ParseSetRef <PIF>(table, "slaves");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
primary_slave = Marshalling.ParseRef <PIF>(table, "primary_slave");
mode = (bond_mode)Helper.EnumParseDefault(typeof(bond_mode), Marshalling.ParseString(table, "mode"));
properties = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "properties"));
links_up = Marshalling.ParseLong(table, "links_up");
}
/// <summary>
/// Creates a new PCI from a Hashtable.
/// </summary>
/// <param name="table"></param>
public PCI(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
class_name = Marshalling.ParseString(table, "class_name");
vendor_name = Marshalling.ParseString(table, "vendor_name");
device_name = Marshalling.ParseString(table, "device_name");
host = Marshalling.ParseRef <Host>(table, "host");
pci_id = Marshalling.ParseString(table, "pci_id");
dependencies = Marshalling.ParseSetRef <PCI>(table, "dependencies");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this DR_task
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("introduced_SRs"))
{
introduced_SRs = Marshalling.ParseSetRef <SR>(table, "introduced_SRs");
}
}
/// <summary>
/// Creates a new Pool_update from a Hashtable.
/// </summary>
/// <param name="table"></param>
public Pool_update(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
installation_size = Marshalling.ParseLong(table, "installation_size");
key = Marshalling.ParseString(table, "key");
after_apply_guidance = Helper.StringArrayToEnumList <update_after_apply_guidance>(Marshalling.ParseStringArray(table, "after_apply_guidance"));
vdi = Marshalling.ParseRef <VDI>(table, "vdi");
hosts = Marshalling.ParseSetRef <Host>(table, "hosts");
}
/// <summary>
/// Creates a new Pool_patch from a Hashtable.
/// </summary>
/// <param name="table"></param>
public Pool_patch(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
version = Marshalling.ParseString(table, "version");
size = Marshalling.ParseLong(table, "size");
pool_applied = Marshalling.ParseBool(table, "pool_applied");
host_patches = Marshalling.ParseSetRef <Host_patch>(table, "host_patches");
after_apply_guidance = Helper.StringArrayToEnumList <after_apply_guidance>(Marshalling.ParseStringArray(table, "after_apply_guidance"));
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
/// <summary>
/// Creates a new PGPU from a Hashtable.
/// </summary>
/// <param name="table"></param>
public PGPU(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
PCI = Marshalling.ParseRef <PCI>(table, "PCI");
GPU_group = Marshalling.ParseRef <GPU_group>(table, "GPU_group");
host = Marshalling.ParseRef <Host>(table, "host");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
supported_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "supported_VGPU_types");
enabled_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "enabled_VGPU_types");
resident_VGPUs = Marshalling.ParseSetRef <VGPU>(table, "resident_VGPUs");
supported_VGPU_max_capacities = Maps.convert_from_proxy_XenRefVGPU_type_long(Marshalling.ParseHashTable(table, "supported_VGPU_max_capacities"));
}
/// <summary>
/// Creates a new GPU_group from a Hashtable.
/// </summary>
/// <param name="table"></param>
public GPU_group(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
PGPUs = Marshalling.ParseSetRef <PGPU>(table, "PGPUs");
VGPUs = Marshalling.ParseSetRef <VGPU>(table, "VGPUs");
GPU_types = Marshalling.ParseStringArray(table, "GPU_types");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
allocation_algorithm = (allocation_algorithm)Helper.EnumParseDefault(typeof(allocation_algorithm), Marshalling.ParseString(table, "allocation_algorithm"));
supported_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "supported_VGPU_types");
enabled_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "enabled_VGPU_types");
}
/// <summary>
/// Creates a new VMSS from a Hashtable.
/// </summary>
/// <param name="table"></param>
public VMSS(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
enabled = Marshalling.ParseBool(table, "enabled");
type = (vmss_type)Helper.EnumParseDefault(typeof(vmss_type), Marshalling.ParseString(table, "type"));
retained_snapshots = Marshalling.ParseLong(table, "retained_snapshots");
frequency = (vmss_frequency)Helper.EnumParseDefault(typeof(vmss_frequency), Marshalling.ParseString(table, "frequency"));
schedule = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "schedule"));
last_run_time = Marshalling.ParseDateTime(table, "last_run_time");
VMs = Marshalling.ParseSetRef <VM>(table, "VMs");
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this Cluster
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("cluster_hosts"))
{
cluster_hosts = Marshalling.ParseSetRef <Cluster_host>(table, "cluster_hosts");
}
if (table.ContainsKey("network"))
{
network = Marshalling.ParseRef <Network>(table, "network");
}
if (table.ContainsKey("cluster_token"))
{
cluster_token = Marshalling.ParseString(table, "cluster_token");
}
if (table.ContainsKey("cluster_stack"))
{
cluster_stack = Marshalling.ParseString(table, "cluster_stack");
}
if (table.ContainsKey("allowed_operations"))
{
allowed_operations = Helper.StringArrayToEnumList <cluster_operation>(Marshalling.ParseStringArray(table, "allowed_operations"));
}
if (table.ContainsKey("current_operations"))
{
current_operations = Maps.convert_from_proxy_string_cluster_operation(Marshalling.ParseHashTable(table, "current_operations"));
}
if (table.ContainsKey("pool_auto_join"))
{
pool_auto_join = Marshalling.ParseBool(table, "pool_auto_join");
}
if (table.ContainsKey("token_timeout"))
{
token_timeout = Marshalling.ParseLong(table, "token_timeout");
}
if (table.ContainsKey("token_timeout_coefficient"))
{
token_timeout_coefficient = Marshalling.ParseLong(table, "token_timeout_coefficient");
}
if (table.ContainsKey("cluster_config"))
{
cluster_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "cluster_config"));
}
if (table.ContainsKey("other_config"))
{
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this PGPU
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("PCI"))
{
PCI = Marshalling.ParseRef <PCI>(table, "PCI");
}
if (table.ContainsKey("GPU_group"))
{
GPU_group = Marshalling.ParseRef <GPU_group>(table, "GPU_group");
}
if (table.ContainsKey("host"))
{
host = Marshalling.ParseRef <Host>(table, "host");
}
if (table.ContainsKey("other_config"))
{
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
if (table.ContainsKey("supported_VGPU_types"))
{
supported_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "supported_VGPU_types");
}
if (table.ContainsKey("enabled_VGPU_types"))
{
enabled_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "enabled_VGPU_types");
}
if (table.ContainsKey("resident_VGPUs"))
{
resident_VGPUs = Marshalling.ParseSetRef <VGPU>(table, "resident_VGPUs");
}
if (table.ContainsKey("supported_VGPU_max_capacities"))
{
supported_VGPU_max_capacities = Maps.convert_from_proxy_XenRefVGPU_type_long(Marshalling.ParseHashTable(table, "supported_VGPU_max_capacities"));
}
if (table.ContainsKey("dom0_access"))
{
dom0_access = (pgpu_dom0_access)Helper.EnumParseDefault(typeof(pgpu_dom0_access), Marshalling.ParseString(table, "dom0_access"));
}
if (table.ContainsKey("is_system_display_device"))
{
is_system_display_device = Marshalling.ParseBool(table, "is_system_display_device");
}
if (table.ContainsKey("compatibility_metadata"))
{
compatibility_metadata = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "compatibility_metadata"));
}
}
/// <summary>
/// Creates a new PGPU from a Hashtable.
/// </summary>
/// <param name="table"></param>
public PGPU(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
PCI = Marshalling.ParseRef <PCI>(table, "PCI");
GPU_group = Marshalling.ParseRef <GPU_group>(table, "GPU_group");
host = Marshalling.ParseRef <Host>(table, "host");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
supported_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "supported_VGPU_types");
enabled_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "enabled_VGPU_types");
resident_VGPUs = Marshalling.ParseSetRef <VGPU>(table, "resident_VGPUs");
supported_VGPU_max_capacities = Maps.convert_from_proxy_XenRefVGPU_type_long(Marshalling.ParseHashTable(table, "supported_VGPU_max_capacities"));
dom0_access = (pgpu_dom0_access)Helper.EnumParseDefault(typeof(pgpu_dom0_access), Marshalling.ParseString(table, "dom0_access"));
is_system_display_device = Marshalling.ParseBool(table, "is_system_display_device");
}
/// <summary>
/// Creates a new Pool_update from a Hashtable.
/// </summary>
/// <param name="table"></param>
public Pool_update(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
version = Marshalling.ParseString(table, "version");
installation_size = Marshalling.ParseLong(table, "installation_size");
key = Marshalling.ParseString(table, "key");
after_apply_guidance = Helper.StringArrayToEnumList <update_after_apply_guidance>(Marshalling.ParseStringArray(table, "after_apply_guidance"));
vdi = Marshalling.ParseRef <VDI>(table, "vdi");
hosts = Marshalling.ParseSetRef <Host>(table, "hosts");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
enforce_homogeneity = Marshalling.ParseBool(table, "enforce_homogeneity");
}
/// <summary>
/// Creates a new VGPU_type from a Hashtable.
/// </summary>
/// <param name="table"></param>
public VGPU_type(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
vendor_name = Marshalling.ParseString(table, "vendor_name");
model_name = Marshalling.ParseString(table, "model_name");
framebuffer_size = Marshalling.ParseLong(table, "framebuffer_size");
max_heads = Marshalling.ParseLong(table, "max_heads");
max_resolution_x = Marshalling.ParseLong(table, "max_resolution_x");
max_resolution_y = Marshalling.ParseLong(table, "max_resolution_y");
supported_on_PGPUs = Marshalling.ParseSetRef <PGPU>(table, "supported_on_PGPUs");
enabled_on_PGPUs = Marshalling.ParseSetRef <PGPU>(table, "enabled_on_PGPUs");
VGPUs = Marshalling.ParseSetRef <VGPU>(table, "VGPUs");
supported_on_GPU_groups = Marshalling.ParseSetRef <GPU_group>(table, "supported_on_GPU_groups");
enabled_on_GPU_groups = Marshalling.ParseSetRef <GPU_group>(table, "enabled_on_GPU_groups");
}
/// <summary>
/// Creates a new Network from a Hashtable.
/// </summary>
/// <param name="table"></param>
public Network(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
allowed_operations = Helper.StringArrayToEnumList <network_operations>(Marshalling.ParseStringArray(table, "allowed_operations"));
current_operations = Maps.convert_from_proxy_string_network_operations(Marshalling.ParseHashTable(table, "current_operations"));
VIFs = Marshalling.ParseSetRef <VIF>(table, "VIFs");
PIFs = Marshalling.ParseSetRef <PIF>(table, "PIFs");
MTU = Marshalling.ParseLong(table, "MTU");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
bridge = Marshalling.ParseString(table, "bridge");
blobs = Maps.convert_from_proxy_string_XenRefBlob(Marshalling.ParseHashTable(table, "blobs"));
tags = Marshalling.ParseStringArray(table, "tags");
default_locking_mode = (network_default_locking_mode)Helper.EnumParseDefault(typeof(network_default_locking_mode), Marshalling.ParseString(table, "default_locking_mode"));
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this PCI
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("class_name"))
{
class_name = Marshalling.ParseString(table, "class_name");
}
if (table.ContainsKey("vendor_name"))
{
vendor_name = Marshalling.ParseString(table, "vendor_name");
}
if (table.ContainsKey("device_name"))
{
device_name = Marshalling.ParseString(table, "device_name");
}
if (table.ContainsKey("host"))
{
host = Marshalling.ParseRef <Host>(table, "host");
}
if (table.ContainsKey("pci_id"))
{
pci_id = Marshalling.ParseString(table, "pci_id");
}
if (table.ContainsKey("dependencies"))
{
dependencies = Marshalling.ParseSetRef <PCI>(table, "dependencies");
}
if (table.ContainsKey("other_config"))
{
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
if (table.ContainsKey("subsystem_vendor_name"))
{
subsystem_vendor_name = Marshalling.ParseString(table, "subsystem_vendor_name");
}
if (table.ContainsKey("subsystem_device_name"))
{
subsystem_device_name = Marshalling.ParseString(table, "subsystem_device_name");
}
if (table.ContainsKey("driver_name"))
{
driver_name = Marshalling.ParseString(table, "driver_name");
}
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this Pool_update
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("name_label"))
{
name_label = Marshalling.ParseString(table, "name_label");
}
if (table.ContainsKey("name_description"))
{
name_description = Marshalling.ParseString(table, "name_description");
}
if (table.ContainsKey("version"))
{
version = Marshalling.ParseString(table, "version");
}
if (table.ContainsKey("installation_size"))
{
installation_size = Marshalling.ParseLong(table, "installation_size");
}
if (table.ContainsKey("key"))
{
key = Marshalling.ParseString(table, "key");
}
if (table.ContainsKey("after_apply_guidance"))
{
after_apply_guidance = Helper.StringArrayToEnumList <update_after_apply_guidance>(Marshalling.ParseStringArray(table, "after_apply_guidance"));
}
if (table.ContainsKey("vdi"))
{
vdi = Marshalling.ParseRef <VDI>(table, "vdi");
}
if (table.ContainsKey("hosts"))
{
hosts = Marshalling.ParseSetRef <Host>(table, "hosts");
}
if (table.ContainsKey("other_config"))
{
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
}
if (table.ContainsKey("enforce_homogeneity"))
{
enforce_homogeneity = Marshalling.ParseBool(table, "enforce_homogeneity");
}
}
/// <summary>
/// Creates a new VGPU_type from a Hashtable.
/// </summary>
/// <param name="table"></param>
public VGPU_type(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
vendor_name = Marshalling.ParseString(table, "vendor_name");
model_name = Marshalling.ParseString(table, "model_name");
framebuffer_size = Marshalling.ParseLong(table, "framebuffer_size");
max_heads = Marshalling.ParseLong(table, "max_heads");
max_resolution_x = Marshalling.ParseLong(table, "max_resolution_x");
max_resolution_y = Marshalling.ParseLong(table, "max_resolution_y");
supported_on_PGPUs = Marshalling.ParseSetRef <PGPU>(table, "supported_on_PGPUs");
enabled_on_PGPUs = Marshalling.ParseSetRef <PGPU>(table, "enabled_on_PGPUs");
VGPUs = Marshalling.ParseSetRef <VGPU>(table, "VGPUs");
supported_on_GPU_groups = Marshalling.ParseSetRef <GPU_group>(table, "supported_on_GPU_groups");
enabled_on_GPU_groups = Marshalling.ParseSetRef <GPU_group>(table, "enabled_on_GPU_groups");
implementation = (vgpu_type_implementation)Helper.EnumParseDefault(typeof(vgpu_type_implementation), Marshalling.ParseString(table, "implementation"));
identifier = Marshalling.ParseString(table, "identifier");
experimental = Marshalling.ParseBool(table, "experimental");
}
/// <summary>
/// Creates a new Task from a Hashtable.
/// </summary>
/// <param name="table"></param>
public Task(Hashtable table)
{
uuid = Marshalling.ParseString(table, "uuid");
name_label = Marshalling.ParseString(table, "name_label");
name_description = Marshalling.ParseString(table, "name_description");
allowed_operations = Helper.StringArrayToEnumList <task_allowed_operations>(Marshalling.ParseStringArray(table, "allowed_operations"));
current_operations = Maps.convert_from_proxy_string_task_allowed_operations(Marshalling.ParseHashTable(table, "current_operations"));
created = Marshalling.ParseDateTime(table, "created");
finished = Marshalling.ParseDateTime(table, "finished");
status = (task_status_type)Helper.EnumParseDefault(typeof(task_status_type), Marshalling.ParseString(table, "status"));
resident_on = Marshalling.ParseRef <Host>(table, "resident_on");
progress = Marshalling.ParseDouble(table, "progress");
type = Marshalling.ParseString(table, "type");
result = Marshalling.ParseString(table, "result");
error_info = Marshalling.ParseStringArray(table, "error_info");
other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
subtask_of = Marshalling.ParseRef <Task>(table, "subtask_of");
subtasks = Marshalling.ParseSetRef <Task>(table, "subtasks");
}
/// <summary>
/// Given a Hashtable with field-value pairs, it updates the fields of this Role
/// with the values listed in the Hashtable. Note that only the fields contained
/// in the Hashtable will be updated and the rest will remain the same.
/// </summary>
/// <param name="table"></param>
public void UpdateFrom(Hashtable table)
{
if (table.ContainsKey("uuid"))
{
uuid = Marshalling.ParseString(table, "uuid");
}
if (table.ContainsKey("name_label"))
{
name_label = Marshalling.ParseString(table, "name_label");
}
if (table.ContainsKey("name_description"))
{
name_description = Marshalling.ParseString(table, "name_description");
}
if (table.ContainsKey("subroles"))
{
subroles = Marshalling.ParseSetRef <Role>(table, "subroles");
}
}