vif_gen.go

//
// This file is generated. To change the content of this file, please do not
// apply the change to this file because it will get overwritten. Instead,
// change xenapi.go and execute 'go generate'.
//

package xenAPI

import (
	"errors"
	"fmt"
	"log"
	"github.com/amfranz/go-xmlrpc-client"
	"reflect"
	"strconv"
	"time"
)


var _ = errors.New
var _ = log.Println
var _ = fmt.Errorf
var _ = xmlrpc.NewClient
var _ = reflect.TypeOf
var _ = strconv.Atoi
var _ = time.UTC

type VifOperations string

const (
  // Attempting to attach this VIF to a VM
	VifOperationsAttach VifOperations = "attach"
  // Attempting to hotplug this VIF
	VifOperationsPlug VifOperations = "plug"
  // Attempting to hot unplug this VIF
	VifOperationsUnplug VifOperations = "unplug"
)

type VifLockingMode string

const (
  // No specific configuration set - default network policy applies
	VifLockingModeNetworkDefault VifLockingMode = "network_default"
  // Only traffic to a specific MAC and a list of IPv4 or IPv6 addresses is permitted
	VifLockingModeLocked VifLockingMode = "locked"
  // All traffic is permitted
	VifLockingModeUnlocked VifLockingMode = "unlocked"
  // No traffic is permitted
	VifLockingModeDisabled VifLockingMode = "disabled"
)

type VifIpv4ConfigurationMode string

const (
  // Follow the default IPv4 configuration of the guest (this is guest-dependent)
	VifIpv4ConfigurationModeNone VifIpv4ConfigurationMode = "None"
  // Static IPv4 address configuration
	VifIpv4ConfigurationModeStatic VifIpv4ConfigurationMode = "Static"
)

type VifIpv6ConfigurationMode string

const (
  // Follow the default IPv6 configuration of the guest (this is guest-dependent)
	VifIpv6ConfigurationModeNone VifIpv6ConfigurationMode = "None"
  // Static IPv6 address configuration
	VifIpv6ConfigurationModeStatic VifIpv6ConfigurationMode = "Static"
)

type VIFRecord struct {
  // Unique identifier/object reference
	UUID string
  // list of the operations allowed in this state. This list is advisory only and the server state may have changed by the time this field is read by a client.
	AllowedOperations []VifOperations
  // links each of the running tasks using this object (by reference) to a current_operation enum which describes the nature of the task.
	CurrentOperations map[string]VifOperations
  // order in which VIF backends are created by xapi
	Device string
  // virtual network to which this vif is connected
	Network NetworkRef
  // virtual machine to which this vif is connected
	VM VMRef
  // ethernet MAC address of virtual interface, as exposed to guest
	MAC string
  // MTU in octets
	MTU int
  // additional configuration
	OtherConfig map[string]string
  // is the device currently attached (erased on reboot)
	CurrentlyAttached bool
  // error/success code associated with last attach-operation (erased on reboot)
	StatusCode int
  // error/success information associated with last attach-operation status (erased on reboot)
	StatusDetail string
  // Device runtime properties
	RuntimeProperties map[string]string
  // QoS algorithm to use
	QosAlgorithmType string
  // parameters for chosen QoS algorithm
	QosAlgorithmParams map[string]string
  // supported QoS algorithms for this VIF
	QosSupportedAlgorithms []string
  // metrics associated with this VIF
	Metrics VIFMetricsRef
  // true if the MAC was autogenerated; false indicates it was set manually
	MACAutogenerated bool
  // current locking mode of the VIF
	LockingMode VifLockingMode
  // A list of IPv4 addresses which can be used to filter traffic passing through this VIF
	Ipv4Allowed []string
  // A list of IPv6 addresses which can be used to filter traffic passing through this VIF
	Ipv6Allowed []string
  // Determines whether IPv4 addresses are configured on the VIF
	Ipv4ConfigurationMode VifIpv4ConfigurationMode
  // IPv4 addresses in CIDR format
	Ipv4Addresses []string
  // IPv4 gateway (the empty string means that no gateway is set)
	Ipv4Gateway string
  // Determines whether IPv6 addresses are configured on the VIF
	Ipv6ConfigurationMode VifIpv6ConfigurationMode
  // IPv6 addresses in CIDR format
	Ipv6Addresses []string
  // IPv6 gateway (the empty string means that no gateway is set)
	Ipv6Gateway string
}

type VIFRef string

// A virtual network interface
type VIFClass struct {
	client *Client
}


func VIFClassGetAllRecordsMockDefault(sessionID SessionRef) (_retval map[VIFRef]VIFRecord, _err error) {
	log.Println("VIF.GetAllRecords not mocked")
	_err = errors.New("VIF.GetAllRecords not mocked")
	return
}

var VIFClassGetAllRecordsMockedCallback = VIFClassGetAllRecordsMockDefault

func (_class VIFClass) GetAllRecordsMock(sessionID SessionRef) (_retval map[VIFRef]VIFRecord, _err error) {
	return VIFClassGetAllRecordsMockedCallback(sessionID)
}
// Return a map of VIF references to VIF records for all VIFs known to the system.
func (_class VIFClass) GetAllRecords(sessionID SessionRef) (_retval map[VIFRef]VIFRecord, _err error) {
	if IsMock {
		return _class.GetAllRecordsMock(sessionID)
	}	
	_method := "VIF.get_all_records"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg)
	if _err != nil {
		return
	}
	_retval, _err = convertVIFRefToVIFRecordMapToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetAllMockDefault(sessionID SessionRef) (_retval []VIFRef, _err error) {
	log.Println("VIF.GetAll not mocked")
	_err = errors.New("VIF.GetAll not mocked")
	return
}

var VIFClassGetAllMockedCallback = VIFClassGetAllMockDefault

func (_class VIFClass) GetAllMock(sessionID SessionRef) (_retval []VIFRef, _err error) {
	return VIFClassGetAllMockedCallback(sessionID)
}
// Return a list of all the VIFs known to the system.
func (_class VIFClass) GetAll(sessionID SessionRef) (_retval []VIFRef, _err error) {
	if IsMock {
		return _class.GetAllMock(sessionID)
	}	
	_method := "VIF.get_all"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg)
	if _err != nil {
		return
	}
	_retval, _err = convertVIFRefSetToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassConfigureIpv6MockDefault(sessionID SessionRef, self VIFRef, mode VifIpv6ConfigurationMode, address string, gateway string) (_err error) {
	log.Println("VIF.ConfigureIpv6 not mocked")
	_err = errors.New("VIF.ConfigureIpv6 not mocked")
	return
}

var VIFClassConfigureIpv6MockedCallback = VIFClassConfigureIpv6MockDefault

func (_class VIFClass) ConfigureIpv6Mock(sessionID SessionRef, self VIFRef, mode VifIpv6ConfigurationMode, address string, gateway string) (_err error) {
	return VIFClassConfigureIpv6MockedCallback(sessionID, self, mode, address, gateway)
}
// Configure IPv6 settings for this virtual interface
func (_class VIFClass) ConfigureIpv6(sessionID SessionRef, self VIFRef, mode VifIpv6ConfigurationMode, address string, gateway string) (_err error) {
	if IsMock {
		return _class.ConfigureIpv6Mock(sessionID, self, mode, address, gateway)
	}	
	_method := "VIF.configure_ipv6"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_modeArg, _err := convertEnumVifIpv6ConfigurationModeToXen(fmt.Sprintf("%s(%s)", _method, "mode"), mode)
	if _err != nil {
		return
	}
	_addressArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "address"), address)
	if _err != nil {
		return
	}
	_gatewayArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "gateway"), gateway)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _modeArg, _addressArg, _gatewayArg)
	return
}


func VIFClassConfigureIpv4MockDefault(sessionID SessionRef, self VIFRef, mode VifIpv4ConfigurationMode, address string, gateway string) (_err error) {
	log.Println("VIF.ConfigureIpv4 not mocked")
	_err = errors.New("VIF.ConfigureIpv4 not mocked")
	return
}

var VIFClassConfigureIpv4MockedCallback = VIFClassConfigureIpv4MockDefault

func (_class VIFClass) ConfigureIpv4Mock(sessionID SessionRef, self VIFRef, mode VifIpv4ConfigurationMode, address string, gateway string) (_err error) {
	return VIFClassConfigureIpv4MockedCallback(sessionID, self, mode, address, gateway)
}
// Configure IPv4 settings for this virtual interface
func (_class VIFClass) ConfigureIpv4(sessionID SessionRef, self VIFRef, mode VifIpv4ConfigurationMode, address string, gateway string) (_err error) {
	if IsMock {
		return _class.ConfigureIpv4Mock(sessionID, self, mode, address, gateway)
	}	
	_method := "VIF.configure_ipv4"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_modeArg, _err := convertEnumVifIpv4ConfigurationModeToXen(fmt.Sprintf("%s(%s)", _method, "mode"), mode)
	if _err != nil {
		return
	}
	_addressArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "address"), address)
	if _err != nil {
		return
	}
	_gatewayArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "gateway"), gateway)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _modeArg, _addressArg, _gatewayArg)
	return
}


func VIFClassRemoveIpv6AllowedMockDefault(sessionID SessionRef, self VIFRef, value string) (_err error) {
	log.Println("VIF.RemoveIpv6Allowed not mocked")
	_err = errors.New("VIF.RemoveIpv6Allowed not mocked")
	return
}

var VIFClassRemoveIpv6AllowedMockedCallback = VIFClassRemoveIpv6AllowedMockDefault

func (_class VIFClass) RemoveIpv6AllowedMock(sessionID SessionRef, self VIFRef, value string) (_err error) {
	return VIFClassRemoveIpv6AllowedMockedCallback(sessionID, self, value)
}
// Removes an IPv6 address from this VIF
func (_class VIFClass) RemoveIpv6Allowed(sessionID SessionRef, self VIFRef, value string) (_err error) {
	if IsMock {
		return _class.RemoveIpv6AllowedMock(sessionID, self, value)
	}	
	_method := "VIF.remove_ipv6_allowed"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassAddIpv6AllowedMockDefault(sessionID SessionRef, self VIFRef, value string) (_err error) {
	log.Println("VIF.AddIpv6Allowed not mocked")
	_err = errors.New("VIF.AddIpv6Allowed not mocked")
	return
}

var VIFClassAddIpv6AllowedMockedCallback = VIFClassAddIpv6AllowedMockDefault

func (_class VIFClass) AddIpv6AllowedMock(sessionID SessionRef, self VIFRef, value string) (_err error) {
	return VIFClassAddIpv6AllowedMockedCallback(sessionID, self, value)
}
// Associates an IPv6 address with this VIF
func (_class VIFClass) AddIpv6Allowed(sessionID SessionRef, self VIFRef, value string) (_err error) {
	if IsMock {
		return _class.AddIpv6AllowedMock(sessionID, self, value)
	}	
	_method := "VIF.add_ipv6_allowed"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassSetIpv6AllowedMockDefault(sessionID SessionRef, self VIFRef, value []string) (_err error) {
	log.Println("VIF.SetIpv6Allowed not mocked")
	_err = errors.New("VIF.SetIpv6Allowed not mocked")
	return
}

var VIFClassSetIpv6AllowedMockedCallback = VIFClassSetIpv6AllowedMockDefault

func (_class VIFClass) SetIpv6AllowedMock(sessionID SessionRef, self VIFRef, value []string) (_err error) {
	return VIFClassSetIpv6AllowedMockedCallback(sessionID, self, value)
}
// Set the IPv6 addresses to which traffic on this VIF can be restricted
func (_class VIFClass) SetIpv6Allowed(sessionID SessionRef, self VIFRef, value []string) (_err error) {
	if IsMock {
		return _class.SetIpv6AllowedMock(sessionID, self, value)
	}	
	_method := "VIF.set_ipv6_allowed"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringSetToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassRemoveIpv4AllowedMockDefault(sessionID SessionRef, self VIFRef, value string) (_err error) {
	log.Println("VIF.RemoveIpv4Allowed not mocked")
	_err = errors.New("VIF.RemoveIpv4Allowed not mocked")
	return
}

var VIFClassRemoveIpv4AllowedMockedCallback = VIFClassRemoveIpv4AllowedMockDefault

func (_class VIFClass) RemoveIpv4AllowedMock(sessionID SessionRef, self VIFRef, value string) (_err error) {
	return VIFClassRemoveIpv4AllowedMockedCallback(sessionID, self, value)
}
// Removes an IPv4 address from this VIF
func (_class VIFClass) RemoveIpv4Allowed(sessionID SessionRef, self VIFRef, value string) (_err error) {
	if IsMock {
		return _class.RemoveIpv4AllowedMock(sessionID, self, value)
	}	
	_method := "VIF.remove_ipv4_allowed"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassAddIpv4AllowedMockDefault(sessionID SessionRef, self VIFRef, value string) (_err error) {
	log.Println("VIF.AddIpv4Allowed not mocked")
	_err = errors.New("VIF.AddIpv4Allowed not mocked")
	return
}

var VIFClassAddIpv4AllowedMockedCallback = VIFClassAddIpv4AllowedMockDefault

func (_class VIFClass) AddIpv4AllowedMock(sessionID SessionRef, self VIFRef, value string) (_err error) {
	return VIFClassAddIpv4AllowedMockedCallback(sessionID, self, value)
}
// Associates an IPv4 address with this VIF
func (_class VIFClass) AddIpv4Allowed(sessionID SessionRef, self VIFRef, value string) (_err error) {
	if IsMock {
		return _class.AddIpv4AllowedMock(sessionID, self, value)
	}	
	_method := "VIF.add_ipv4_allowed"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassSetIpv4AllowedMockDefault(sessionID SessionRef, self VIFRef, value []string) (_err error) {
	log.Println("VIF.SetIpv4Allowed not mocked")
	_err = errors.New("VIF.SetIpv4Allowed not mocked")
	return
}

var VIFClassSetIpv4AllowedMockedCallback = VIFClassSetIpv4AllowedMockDefault

func (_class VIFClass) SetIpv4AllowedMock(sessionID SessionRef, self VIFRef, value []string) (_err error) {
	return VIFClassSetIpv4AllowedMockedCallback(sessionID, self, value)
}
// Set the IPv4 addresses to which traffic on this VIF can be restricted
func (_class VIFClass) SetIpv4Allowed(sessionID SessionRef, self VIFRef, value []string) (_err error) {
	if IsMock {
		return _class.SetIpv4AllowedMock(sessionID, self, value)
	}	
	_method := "VIF.set_ipv4_allowed"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringSetToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassSetLockingModeMockDefault(sessionID SessionRef, self VIFRef, value VifLockingMode) (_err error) {
	log.Println("VIF.SetLockingMode not mocked")
	_err = errors.New("VIF.SetLockingMode not mocked")
	return
}

var VIFClassSetLockingModeMockedCallback = VIFClassSetLockingModeMockDefault

func (_class VIFClass) SetLockingModeMock(sessionID SessionRef, self VIFRef, value VifLockingMode) (_err error) {
	return VIFClassSetLockingModeMockedCallback(sessionID, self, value)
}
// Set the locking mode for this VIF
func (_class VIFClass) SetLockingMode(sessionID SessionRef, self VIFRef, value VifLockingMode) (_err error) {
	if IsMock {
		return _class.SetLockingModeMock(sessionID, self, value)
	}	
	_method := "VIF.set_locking_mode"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertEnumVifLockingModeToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassMoveMockDefault(sessionID SessionRef, self VIFRef, network NetworkRef) (_err error) {
	log.Println("VIF.Move not mocked")
	_err = errors.New("VIF.Move not mocked")
	return
}

var VIFClassMoveMockedCallback = VIFClassMoveMockDefault

func (_class VIFClass) MoveMock(sessionID SessionRef, self VIFRef, network NetworkRef) (_err error) {
	return VIFClassMoveMockedCallback(sessionID, self, network)
}
// Move the specified VIF to the specified network, even while the VM is running
func (_class VIFClass) Move(sessionID SessionRef, self VIFRef, network NetworkRef) (_err error) {
	if IsMock {
		return _class.MoveMock(sessionID, self, network)
	}	
	_method := "VIF.move"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_networkArg, _err := convertNetworkRefToXen(fmt.Sprintf("%s(%s)", _method, "network"), network)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _networkArg)
	return
}


func VIFClassUnplugForceMockDefault(sessionID SessionRef, self VIFRef) (_err error) {
	log.Println("VIF.UnplugForce not mocked")
	_err = errors.New("VIF.UnplugForce not mocked")
	return
}

var VIFClassUnplugForceMockedCallback = VIFClassUnplugForceMockDefault

func (_class VIFClass) UnplugForceMock(sessionID SessionRef, self VIFRef) (_err error) {
	return VIFClassUnplugForceMockedCallback(sessionID, self)
}
// Forcibly unplug the specified VIF
func (_class VIFClass) UnplugForce(sessionID SessionRef, self VIFRef) (_err error) {
	if IsMock {
		return _class.UnplugForceMock(sessionID, self)
	}	
	_method := "VIF.unplug_force"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg)
	return
}


func VIFClassUnplugMockDefault(sessionID SessionRef, self VIFRef) (_err error) {
	log.Println("VIF.Unplug not mocked")
	_err = errors.New("VIF.Unplug not mocked")
	return
}

var VIFClassUnplugMockedCallback = VIFClassUnplugMockDefault

func (_class VIFClass) UnplugMock(sessionID SessionRef, self VIFRef) (_err error) {
	return VIFClassUnplugMockedCallback(sessionID, self)
}
// Hot-unplug the specified VIF, dynamically unattaching it from the running VM
func (_class VIFClass) Unplug(sessionID SessionRef, self VIFRef) (_err error) {
	if IsMock {
		return _class.UnplugMock(sessionID, self)
	}	
	_method := "VIF.unplug"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg)
	return
}


func VIFClassPlugMockDefault(sessionID SessionRef, self VIFRef) (_err error) {
	log.Println("VIF.Plug not mocked")
	_err = errors.New("VIF.Plug not mocked")
	return
}

var VIFClassPlugMockedCallback = VIFClassPlugMockDefault

func (_class VIFClass) PlugMock(sessionID SessionRef, self VIFRef) (_err error) {
	return VIFClassPlugMockedCallback(sessionID, self)
}
// Hotplug the specified VIF, dynamically attaching it to the running VM
func (_class VIFClass) Plug(sessionID SessionRef, self VIFRef) (_err error) {
	if IsMock {
		return _class.PlugMock(sessionID, self)
	}	
	_method := "VIF.plug"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg)
	return
}


func VIFClassRemoveFromQosAlgorithmParamsMockDefault(sessionID SessionRef, self VIFRef, key string) (_err error) {
	log.Println("VIF.RemoveFromQosAlgorithmParams not mocked")
	_err = errors.New("VIF.RemoveFromQosAlgorithmParams not mocked")
	return
}

var VIFClassRemoveFromQosAlgorithmParamsMockedCallback = VIFClassRemoveFromQosAlgorithmParamsMockDefault

func (_class VIFClass) RemoveFromQosAlgorithmParamsMock(sessionID SessionRef, self VIFRef, key string) (_err error) {
	return VIFClassRemoveFromQosAlgorithmParamsMockedCallback(sessionID, self, key)
}
// Remove the given key and its corresponding value from the qos/algorithm_params field of the given VIF.  If the key is not in that Map, then do nothing.
func (_class VIFClass) RemoveFromQosAlgorithmParams(sessionID SessionRef, self VIFRef, key string) (_err error) {
	if IsMock {
		return _class.RemoveFromQosAlgorithmParamsMock(sessionID, self, key)
	}	
	_method := "VIF.remove_from_qos_algorithm_params"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_keyArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "key"), key)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _keyArg)
	return
}


func VIFClassAddToQosAlgorithmParamsMockDefault(sessionID SessionRef, self VIFRef, key string, value string) (_err error) {
	log.Println("VIF.AddToQosAlgorithmParams not mocked")
	_err = errors.New("VIF.AddToQosAlgorithmParams not mocked")
	return
}

var VIFClassAddToQosAlgorithmParamsMockedCallback = VIFClassAddToQosAlgorithmParamsMockDefault

func (_class VIFClass) AddToQosAlgorithmParamsMock(sessionID SessionRef, self VIFRef, key string, value string) (_err error) {
	return VIFClassAddToQosAlgorithmParamsMockedCallback(sessionID, self, key, value)
}
// Add the given key-value pair to the qos/algorithm_params field of the given VIF.
func (_class VIFClass) AddToQosAlgorithmParams(sessionID SessionRef, self VIFRef, key string, value string) (_err error) {
	if IsMock {
		return _class.AddToQosAlgorithmParamsMock(sessionID, self, key, value)
	}	
	_method := "VIF.add_to_qos_algorithm_params"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_keyArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "key"), key)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _keyArg, _valueArg)
	return
}


func VIFClassSetQosAlgorithmParamsMockDefault(sessionID SessionRef, self VIFRef, value map[string]string) (_err error) {
	log.Println("VIF.SetQosAlgorithmParams not mocked")
	_err = errors.New("VIF.SetQosAlgorithmParams not mocked")
	return
}

var VIFClassSetQosAlgorithmParamsMockedCallback = VIFClassSetQosAlgorithmParamsMockDefault

func (_class VIFClass) SetQosAlgorithmParamsMock(sessionID SessionRef, self VIFRef, value map[string]string) (_err error) {
	return VIFClassSetQosAlgorithmParamsMockedCallback(sessionID, self, value)
}
// Set the qos/algorithm_params field of the given VIF.
func (_class VIFClass) SetQosAlgorithmParams(sessionID SessionRef, self VIFRef, value map[string]string) (_err error) {
	if IsMock {
		return _class.SetQosAlgorithmParamsMock(sessionID, self, value)
	}	
	_method := "VIF.set_qos_algorithm_params"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToStringMapToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassSetQosAlgorithmTypeMockDefault(sessionID SessionRef, self VIFRef, value string) (_err error) {
	log.Println("VIF.SetQosAlgorithmType not mocked")
	_err = errors.New("VIF.SetQosAlgorithmType not mocked")
	return
}

var VIFClassSetQosAlgorithmTypeMockedCallback = VIFClassSetQosAlgorithmTypeMockDefault

func (_class VIFClass) SetQosAlgorithmTypeMock(sessionID SessionRef, self VIFRef, value string) (_err error) {
	return VIFClassSetQosAlgorithmTypeMockedCallback(sessionID, self, value)
}
// Set the qos/algorithm_type field of the given VIF.
func (_class VIFClass) SetQosAlgorithmType(sessionID SessionRef, self VIFRef, value string) (_err error) {
	if IsMock {
		return _class.SetQosAlgorithmTypeMock(sessionID, self, value)
	}	
	_method := "VIF.set_qos_algorithm_type"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassRemoveFromOtherConfigMockDefault(sessionID SessionRef, self VIFRef, key string) (_err error) {
	log.Println("VIF.RemoveFromOtherConfig not mocked")
	_err = errors.New("VIF.RemoveFromOtherConfig not mocked")
	return
}

var VIFClassRemoveFromOtherConfigMockedCallback = VIFClassRemoveFromOtherConfigMockDefault

func (_class VIFClass) RemoveFromOtherConfigMock(sessionID SessionRef, self VIFRef, key string) (_err error) {
	return VIFClassRemoveFromOtherConfigMockedCallback(sessionID, self, key)
}
// Remove the given key and its corresponding value from the other_config field of the given VIF.  If the key is not in that Map, then do nothing.
func (_class VIFClass) RemoveFromOtherConfig(sessionID SessionRef, self VIFRef, key string) (_err error) {
	if IsMock {
		return _class.RemoveFromOtherConfigMock(sessionID, self, key)
	}	
	_method := "VIF.remove_from_other_config"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_keyArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "key"), key)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _keyArg)
	return
}


func VIFClassAddToOtherConfigMockDefault(sessionID SessionRef, self VIFRef, key string, value string) (_err error) {
	log.Println("VIF.AddToOtherConfig not mocked")
	_err = errors.New("VIF.AddToOtherConfig not mocked")
	return
}

var VIFClassAddToOtherConfigMockedCallback = VIFClassAddToOtherConfigMockDefault

func (_class VIFClass) AddToOtherConfigMock(sessionID SessionRef, self VIFRef, key string, value string) (_err error) {
	return VIFClassAddToOtherConfigMockedCallback(sessionID, self, key, value)
}
// Add the given key-value pair to the other_config field of the given VIF.
func (_class VIFClass) AddToOtherConfig(sessionID SessionRef, self VIFRef, key string, value string) (_err error) {
	if IsMock {
		return _class.AddToOtherConfigMock(sessionID, self, key, value)
	}	
	_method := "VIF.add_to_other_config"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_keyArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "key"), key)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _keyArg, _valueArg)
	return
}


func VIFClassSetOtherConfigMockDefault(sessionID SessionRef, self VIFRef, value map[string]string) (_err error) {
	log.Println("VIF.SetOtherConfig not mocked")
	_err = errors.New("VIF.SetOtherConfig not mocked")
	return
}

var VIFClassSetOtherConfigMockedCallback = VIFClassSetOtherConfigMockDefault

func (_class VIFClass) SetOtherConfigMock(sessionID SessionRef, self VIFRef, value map[string]string) (_err error) {
	return VIFClassSetOtherConfigMockedCallback(sessionID, self, value)
}
// Set the other_config field of the given VIF.
func (_class VIFClass) SetOtherConfig(sessionID SessionRef, self VIFRef, value map[string]string) (_err error) {
	if IsMock {
		return _class.SetOtherConfigMock(sessionID, self, value)
	}	
	_method := "VIF.set_other_config"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_valueArg, _err := convertStringToStringMapToXen(fmt.Sprintf("%s(%s)", _method, "value"), value)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg, _valueArg)
	return
}


func VIFClassGetIpv6GatewayMockDefault(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	log.Println("VIF.GetIpv6Gateway not mocked")
	_err = errors.New("VIF.GetIpv6Gateway not mocked")
	return
}

var VIFClassGetIpv6GatewayMockedCallback = VIFClassGetIpv6GatewayMockDefault

func (_class VIFClass) GetIpv6GatewayMock(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	return VIFClassGetIpv6GatewayMockedCallback(sessionID, self)
}
// Get the ipv6_gateway field of the given VIF.
func (_class VIFClass) GetIpv6Gateway(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	if IsMock {
		return _class.GetIpv6GatewayMock(sessionID, self)
	}	
	_method := "VIF.get_ipv6_gateway"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetIpv6AddressesMockDefault(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	log.Println("VIF.GetIpv6Addresses not mocked")
	_err = errors.New("VIF.GetIpv6Addresses not mocked")
	return
}

var VIFClassGetIpv6AddressesMockedCallback = VIFClassGetIpv6AddressesMockDefault

func (_class VIFClass) GetIpv6AddressesMock(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	return VIFClassGetIpv6AddressesMockedCallback(sessionID, self)
}
// Get the ipv6_addresses field of the given VIF.
func (_class VIFClass) GetIpv6Addresses(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	if IsMock {
		return _class.GetIpv6AddressesMock(sessionID, self)
	}	
	_method := "VIF.get_ipv6_addresses"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringSetToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetIpv6ConfigurationModeMockDefault(sessionID SessionRef, self VIFRef) (_retval VifIpv6ConfigurationMode, _err error) {
	log.Println("VIF.GetIpv6ConfigurationMode not mocked")
	_err = errors.New("VIF.GetIpv6ConfigurationMode not mocked")
	return
}

var VIFClassGetIpv6ConfigurationModeMockedCallback = VIFClassGetIpv6ConfigurationModeMockDefault

func (_class VIFClass) GetIpv6ConfigurationModeMock(sessionID SessionRef, self VIFRef) (_retval VifIpv6ConfigurationMode, _err error) {
	return VIFClassGetIpv6ConfigurationModeMockedCallback(sessionID, self)
}
// Get the ipv6_configuration_mode field of the given VIF.
func (_class VIFClass) GetIpv6ConfigurationMode(sessionID SessionRef, self VIFRef) (_retval VifIpv6ConfigurationMode, _err error) {
	if IsMock {
		return _class.GetIpv6ConfigurationModeMock(sessionID, self)
	}	
	_method := "VIF.get_ipv6_configuration_mode"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertEnumVifIpv6ConfigurationModeToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetIpv4GatewayMockDefault(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	log.Println("VIF.GetIpv4Gateway not mocked")
	_err = errors.New("VIF.GetIpv4Gateway not mocked")
	return
}

var VIFClassGetIpv4GatewayMockedCallback = VIFClassGetIpv4GatewayMockDefault

func (_class VIFClass) GetIpv4GatewayMock(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	return VIFClassGetIpv4GatewayMockedCallback(sessionID, self)
}
// Get the ipv4_gateway field of the given VIF.
func (_class VIFClass) GetIpv4Gateway(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	if IsMock {
		return _class.GetIpv4GatewayMock(sessionID, self)
	}	
	_method := "VIF.get_ipv4_gateway"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetIpv4AddressesMockDefault(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	log.Println("VIF.GetIpv4Addresses not mocked")
	_err = errors.New("VIF.GetIpv4Addresses not mocked")
	return
}

var VIFClassGetIpv4AddressesMockedCallback = VIFClassGetIpv4AddressesMockDefault

func (_class VIFClass) GetIpv4AddressesMock(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	return VIFClassGetIpv4AddressesMockedCallback(sessionID, self)
}
// Get the ipv4_addresses field of the given VIF.
func (_class VIFClass) GetIpv4Addresses(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	if IsMock {
		return _class.GetIpv4AddressesMock(sessionID, self)
	}	
	_method := "VIF.get_ipv4_addresses"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringSetToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetIpv4ConfigurationModeMockDefault(sessionID SessionRef, self VIFRef) (_retval VifIpv4ConfigurationMode, _err error) {
	log.Println("VIF.GetIpv4ConfigurationMode not mocked")
	_err = errors.New("VIF.GetIpv4ConfigurationMode not mocked")
	return
}

var VIFClassGetIpv4ConfigurationModeMockedCallback = VIFClassGetIpv4ConfigurationModeMockDefault

func (_class VIFClass) GetIpv4ConfigurationModeMock(sessionID SessionRef, self VIFRef) (_retval VifIpv4ConfigurationMode, _err error) {
	return VIFClassGetIpv4ConfigurationModeMockedCallback(sessionID, self)
}
// Get the ipv4_configuration_mode field of the given VIF.
func (_class VIFClass) GetIpv4ConfigurationMode(sessionID SessionRef, self VIFRef) (_retval VifIpv4ConfigurationMode, _err error) {
	if IsMock {
		return _class.GetIpv4ConfigurationModeMock(sessionID, self)
	}	
	_method := "VIF.get_ipv4_configuration_mode"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertEnumVifIpv4ConfigurationModeToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetIpv6AllowedMockDefault(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	log.Println("VIF.GetIpv6Allowed not mocked")
	_err = errors.New("VIF.GetIpv6Allowed not mocked")
	return
}

var VIFClassGetIpv6AllowedMockedCallback = VIFClassGetIpv6AllowedMockDefault

func (_class VIFClass) GetIpv6AllowedMock(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	return VIFClassGetIpv6AllowedMockedCallback(sessionID, self)
}
// Get the ipv6_allowed field of the given VIF.
func (_class VIFClass) GetIpv6Allowed(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	if IsMock {
		return _class.GetIpv6AllowedMock(sessionID, self)
	}	
	_method := "VIF.get_ipv6_allowed"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringSetToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetIpv4AllowedMockDefault(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	log.Println("VIF.GetIpv4Allowed not mocked")
	_err = errors.New("VIF.GetIpv4Allowed not mocked")
	return
}

var VIFClassGetIpv4AllowedMockedCallback = VIFClassGetIpv4AllowedMockDefault

func (_class VIFClass) GetIpv4AllowedMock(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	return VIFClassGetIpv4AllowedMockedCallback(sessionID, self)
}
// Get the ipv4_allowed field of the given VIF.
func (_class VIFClass) GetIpv4Allowed(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	if IsMock {
		return _class.GetIpv4AllowedMock(sessionID, self)
	}	
	_method := "VIF.get_ipv4_allowed"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringSetToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetLockingModeMockDefault(sessionID SessionRef, self VIFRef) (_retval VifLockingMode, _err error) {
	log.Println("VIF.GetLockingMode not mocked")
	_err = errors.New("VIF.GetLockingMode not mocked")
	return
}

var VIFClassGetLockingModeMockedCallback = VIFClassGetLockingModeMockDefault

func (_class VIFClass) GetLockingModeMock(sessionID SessionRef, self VIFRef) (_retval VifLockingMode, _err error) {
	return VIFClassGetLockingModeMockedCallback(sessionID, self)
}
// Get the locking_mode field of the given VIF.
func (_class VIFClass) GetLockingMode(sessionID SessionRef, self VIFRef) (_retval VifLockingMode, _err error) {
	if IsMock {
		return _class.GetLockingModeMock(sessionID, self)
	}	
	_method := "VIF.get_locking_mode"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertEnumVifLockingModeToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetMACAutogeneratedMockDefault(sessionID SessionRef, self VIFRef) (_retval bool, _err error) {
	log.Println("VIF.GetMACAutogenerated not mocked")
	_err = errors.New("VIF.GetMACAutogenerated not mocked")
	return
}

var VIFClassGetMACAutogeneratedMockedCallback = VIFClassGetMACAutogeneratedMockDefault

func (_class VIFClass) GetMACAutogeneratedMock(sessionID SessionRef, self VIFRef) (_retval bool, _err error) {
	return VIFClassGetMACAutogeneratedMockedCallback(sessionID, self)
}
// Get the MAC_autogenerated field of the given VIF.
func (_class VIFClass) GetMACAutogenerated(sessionID SessionRef, self VIFRef) (_retval bool, _err error) {
	if IsMock {
		return _class.GetMACAutogeneratedMock(sessionID, self)
	}	
	_method := "VIF.get_MAC_autogenerated"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertBoolToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetMetricsMockDefault(sessionID SessionRef, self VIFRef) (_retval VIFMetricsRef, _err error) {
	log.Println("VIF.GetMetrics not mocked")
	_err = errors.New("VIF.GetMetrics not mocked")
	return
}

var VIFClassGetMetricsMockedCallback = VIFClassGetMetricsMockDefault

func (_class VIFClass) GetMetricsMock(sessionID SessionRef, self VIFRef) (_retval VIFMetricsRef, _err error) {
	return VIFClassGetMetricsMockedCallback(sessionID, self)
}
// Get the metrics field of the given VIF.
func (_class VIFClass) GetMetrics(sessionID SessionRef, self VIFRef) (_retval VIFMetricsRef, _err error) {
	if IsMock {
		return _class.GetMetricsMock(sessionID, self)
	}	
	_method := "VIF.get_metrics"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertVIFMetricsRefToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetQosSupportedAlgorithmsMockDefault(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	log.Println("VIF.GetQosSupportedAlgorithms not mocked")
	_err = errors.New("VIF.GetQosSupportedAlgorithms not mocked")
	return
}

var VIFClassGetQosSupportedAlgorithmsMockedCallback = VIFClassGetQosSupportedAlgorithmsMockDefault

func (_class VIFClass) GetQosSupportedAlgorithmsMock(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	return VIFClassGetQosSupportedAlgorithmsMockedCallback(sessionID, self)
}
// Get the qos/supported_algorithms field of the given VIF.
func (_class VIFClass) GetQosSupportedAlgorithms(sessionID SessionRef, self VIFRef) (_retval []string, _err error) {
	if IsMock {
		return _class.GetQosSupportedAlgorithmsMock(sessionID, self)
	}	
	_method := "VIF.get_qos_supported_algorithms"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringSetToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetQosAlgorithmParamsMockDefault(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	log.Println("VIF.GetQosAlgorithmParams not mocked")
	_err = errors.New("VIF.GetQosAlgorithmParams not mocked")
	return
}

var VIFClassGetQosAlgorithmParamsMockedCallback = VIFClassGetQosAlgorithmParamsMockDefault

func (_class VIFClass) GetQosAlgorithmParamsMock(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	return VIFClassGetQosAlgorithmParamsMockedCallback(sessionID, self)
}
// Get the qos/algorithm_params field of the given VIF.
func (_class VIFClass) GetQosAlgorithmParams(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	if IsMock {
		return _class.GetQosAlgorithmParamsMock(sessionID, self)
	}	
	_method := "VIF.get_qos_algorithm_params"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToStringMapToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetQosAlgorithmTypeMockDefault(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	log.Println("VIF.GetQosAlgorithmType not mocked")
	_err = errors.New("VIF.GetQosAlgorithmType not mocked")
	return
}

var VIFClassGetQosAlgorithmTypeMockedCallback = VIFClassGetQosAlgorithmTypeMockDefault

func (_class VIFClass) GetQosAlgorithmTypeMock(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	return VIFClassGetQosAlgorithmTypeMockedCallback(sessionID, self)
}
// Get the qos/algorithm_type field of the given VIF.
func (_class VIFClass) GetQosAlgorithmType(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	if IsMock {
		return _class.GetQosAlgorithmTypeMock(sessionID, self)
	}	
	_method := "VIF.get_qos_algorithm_type"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetRuntimePropertiesMockDefault(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	log.Println("VIF.GetRuntimeProperties not mocked")
	_err = errors.New("VIF.GetRuntimeProperties not mocked")
	return
}

var VIFClassGetRuntimePropertiesMockedCallback = VIFClassGetRuntimePropertiesMockDefault

func (_class VIFClass) GetRuntimePropertiesMock(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	return VIFClassGetRuntimePropertiesMockedCallback(sessionID, self)
}
// Get the runtime_properties field of the given VIF.
func (_class VIFClass) GetRuntimeProperties(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	if IsMock {
		return _class.GetRuntimePropertiesMock(sessionID, self)
	}	
	_method := "VIF.get_runtime_properties"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToStringMapToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetStatusDetailMockDefault(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	log.Println("VIF.GetStatusDetail not mocked")
	_err = errors.New("VIF.GetStatusDetail not mocked")
	return
}

var VIFClassGetStatusDetailMockedCallback = VIFClassGetStatusDetailMockDefault

func (_class VIFClass) GetStatusDetailMock(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	return VIFClassGetStatusDetailMockedCallback(sessionID, self)
}
// Get the status_detail field of the given VIF.
func (_class VIFClass) GetStatusDetail(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	if IsMock {
		return _class.GetStatusDetailMock(sessionID, self)
	}	
	_method := "VIF.get_status_detail"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetStatusCodeMockDefault(sessionID SessionRef, self VIFRef) (_retval int, _err error) {
	log.Println("VIF.GetStatusCode not mocked")
	_err = errors.New("VIF.GetStatusCode not mocked")
	return
}

var VIFClassGetStatusCodeMockedCallback = VIFClassGetStatusCodeMockDefault

func (_class VIFClass) GetStatusCodeMock(sessionID SessionRef, self VIFRef) (_retval int, _err error) {
	return VIFClassGetStatusCodeMockedCallback(sessionID, self)
}
// Get the status_code field of the given VIF.
func (_class VIFClass) GetStatusCode(sessionID SessionRef, self VIFRef) (_retval int, _err error) {
	if IsMock {
		return _class.GetStatusCodeMock(sessionID, self)
	}	
	_method := "VIF.get_status_code"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertIntToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetCurrentlyAttachedMockDefault(sessionID SessionRef, self VIFRef) (_retval bool, _err error) {
	log.Println("VIF.GetCurrentlyAttached not mocked")
	_err = errors.New("VIF.GetCurrentlyAttached not mocked")
	return
}

var VIFClassGetCurrentlyAttachedMockedCallback = VIFClassGetCurrentlyAttachedMockDefault

func (_class VIFClass) GetCurrentlyAttachedMock(sessionID SessionRef, self VIFRef) (_retval bool, _err error) {
	return VIFClassGetCurrentlyAttachedMockedCallback(sessionID, self)
}
// Get the currently_attached field of the given VIF.
func (_class VIFClass) GetCurrentlyAttached(sessionID SessionRef, self VIFRef) (_retval bool, _err error) {
	if IsMock {
		return _class.GetCurrentlyAttachedMock(sessionID, self)
	}	
	_method := "VIF.get_currently_attached"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertBoolToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetOtherConfigMockDefault(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	log.Println("VIF.GetOtherConfig not mocked")
	_err = errors.New("VIF.GetOtherConfig not mocked")
	return
}

var VIFClassGetOtherConfigMockedCallback = VIFClassGetOtherConfigMockDefault

func (_class VIFClass) GetOtherConfigMock(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	return VIFClassGetOtherConfigMockedCallback(sessionID, self)
}
// Get the other_config field of the given VIF.
func (_class VIFClass) GetOtherConfig(sessionID SessionRef, self VIFRef) (_retval map[string]string, _err error) {
	if IsMock {
		return _class.GetOtherConfigMock(sessionID, self)
	}	
	_method := "VIF.get_other_config"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToStringMapToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetMTUMockDefault(sessionID SessionRef, self VIFRef) (_retval int, _err error) {
	log.Println("VIF.GetMTU not mocked")
	_err = errors.New("VIF.GetMTU not mocked")
	return
}

var VIFClassGetMTUMockedCallback = VIFClassGetMTUMockDefault

func (_class VIFClass) GetMTUMock(sessionID SessionRef, self VIFRef) (_retval int, _err error) {
	return VIFClassGetMTUMockedCallback(sessionID, self)
}
// Get the MTU field of the given VIF.
func (_class VIFClass) GetMTU(sessionID SessionRef, self VIFRef) (_retval int, _err error) {
	if IsMock {
		return _class.GetMTUMock(sessionID, self)
	}	
	_method := "VIF.get_MTU"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertIntToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetMACMockDefault(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	log.Println("VIF.GetMAC not mocked")
	_err = errors.New("VIF.GetMAC not mocked")
	return
}

var VIFClassGetMACMockedCallback = VIFClassGetMACMockDefault

func (_class VIFClass) GetMACMock(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	return VIFClassGetMACMockedCallback(sessionID, self)
}
// Get the MAC field of the given VIF.
func (_class VIFClass) GetMAC(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	if IsMock {
		return _class.GetMACMock(sessionID, self)
	}	
	_method := "VIF.get_MAC"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetVMMockDefault(sessionID SessionRef, self VIFRef) (_retval VMRef, _err error) {
	log.Println("VIF.GetVM not mocked")
	_err = errors.New("VIF.GetVM not mocked")
	return
}

var VIFClassGetVMMockedCallback = VIFClassGetVMMockDefault

func (_class VIFClass) GetVMMock(sessionID SessionRef, self VIFRef) (_retval VMRef, _err error) {
	return VIFClassGetVMMockedCallback(sessionID, self)
}
// Get the VM field of the given VIF.
func (_class VIFClass) GetVM(sessionID SessionRef, self VIFRef) (_retval VMRef, _err error) {
	if IsMock {
		return _class.GetVMMock(sessionID, self)
	}	
	_method := "VIF.get_VM"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertVMRefToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetNetworkMockDefault(sessionID SessionRef, self VIFRef) (_retval NetworkRef, _err error) {
	log.Println("VIF.GetNetwork not mocked")
	_err = errors.New("VIF.GetNetwork not mocked")
	return
}

var VIFClassGetNetworkMockedCallback = VIFClassGetNetworkMockDefault

func (_class VIFClass) GetNetworkMock(sessionID SessionRef, self VIFRef) (_retval NetworkRef, _err error) {
	return VIFClassGetNetworkMockedCallback(sessionID, self)
}
// Get the network field of the given VIF.
func (_class VIFClass) GetNetwork(sessionID SessionRef, self VIFRef) (_retval NetworkRef, _err error) {
	if IsMock {
		return _class.GetNetworkMock(sessionID, self)
	}	
	_method := "VIF.get_network"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertNetworkRefToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetDeviceMockDefault(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	log.Println("VIF.GetDevice not mocked")
	_err = errors.New("VIF.GetDevice not mocked")
	return
}

var VIFClassGetDeviceMockedCallback = VIFClassGetDeviceMockDefault

func (_class VIFClass) GetDeviceMock(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	return VIFClassGetDeviceMockedCallback(sessionID, self)
}
// Get the device field of the given VIF.
func (_class VIFClass) GetDevice(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	if IsMock {
		return _class.GetDeviceMock(sessionID, self)
	}	
	_method := "VIF.get_device"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetCurrentOperationsMockDefault(sessionID SessionRef, self VIFRef) (_retval map[string]VifOperations, _err error) {
	log.Println("VIF.GetCurrentOperations not mocked")
	_err = errors.New("VIF.GetCurrentOperations not mocked")
	return
}

var VIFClassGetCurrentOperationsMockedCallback = VIFClassGetCurrentOperationsMockDefault

func (_class VIFClass) GetCurrentOperationsMock(sessionID SessionRef, self VIFRef) (_retval map[string]VifOperations, _err error) {
	return VIFClassGetCurrentOperationsMockedCallback(sessionID, self)
}
// Get the current_operations field of the given VIF.
func (_class VIFClass) GetCurrentOperations(sessionID SessionRef, self VIFRef) (_retval map[string]VifOperations, _err error) {
	if IsMock {
		return _class.GetCurrentOperationsMock(sessionID, self)
	}	
	_method := "VIF.get_current_operations"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToEnumVifOperationsMapToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetAllowedOperationsMockDefault(sessionID SessionRef, self VIFRef) (_retval []VifOperations, _err error) {
	log.Println("VIF.GetAllowedOperations not mocked")
	_err = errors.New("VIF.GetAllowedOperations not mocked")
	return
}

var VIFClassGetAllowedOperationsMockedCallback = VIFClassGetAllowedOperationsMockDefault

func (_class VIFClass) GetAllowedOperationsMock(sessionID SessionRef, self VIFRef) (_retval []VifOperations, _err error) {
	return VIFClassGetAllowedOperationsMockedCallback(sessionID, self)
}
// Get the allowed_operations field of the given VIF.
func (_class VIFClass) GetAllowedOperations(sessionID SessionRef, self VIFRef) (_retval []VifOperations, _err error) {
	if IsMock {
		return _class.GetAllowedOperationsMock(sessionID, self)
	}	
	_method := "VIF.get_allowed_operations"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertEnumVifOperationsSetToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetUUIDMockDefault(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	log.Println("VIF.GetUUID not mocked")
	_err = errors.New("VIF.GetUUID not mocked")
	return
}

var VIFClassGetUUIDMockedCallback = VIFClassGetUUIDMockDefault

func (_class VIFClass) GetUUIDMock(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	return VIFClassGetUUIDMockedCallback(sessionID, self)
}
// Get the uuid field of the given VIF.
func (_class VIFClass) GetUUID(sessionID SessionRef, self VIFRef) (_retval string, _err error) {
	if IsMock {
		return _class.GetUUIDMock(sessionID, self)
	}	
	_method := "VIF.get_uuid"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertStringToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassDestroyMockDefault(sessionID SessionRef, self VIFRef) (_err error) {
	log.Println("VIF.Destroy not mocked")
	_err = errors.New("VIF.Destroy not mocked")
	return
}

var VIFClassDestroyMockedCallback = VIFClassDestroyMockDefault

func (_class VIFClass) DestroyMock(sessionID SessionRef, self VIFRef) (_err error) {
	return VIFClassDestroyMockedCallback(sessionID, self)
}
// Destroy the specified VIF instance.
func (_class VIFClass) Destroy(sessionID SessionRef, self VIFRef) (_err error) {
	if IsMock {
		return _class.DestroyMock(sessionID, self)
	}	
	_method := "VIF.destroy"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_, _err =  _class.client.APICall(_method, _sessionIDArg, _selfArg)
	return
}


func VIFClassCreateMockDefault(sessionID SessionRef, args VIFRecord) (_retval VIFRef, _err error) {
	log.Println("VIF.Create not mocked")
	_err = errors.New("VIF.Create not mocked")
	return
}

var VIFClassCreateMockedCallback = VIFClassCreateMockDefault

func (_class VIFClass) CreateMock(sessionID SessionRef, args VIFRecord) (_retval VIFRef, _err error) {
	return VIFClassCreateMockedCallback(sessionID, args)
}
// Create a new VIF instance, and return its handle.
// The constructor args are: device*, network*, VM*, MAC*, MTU*, other_config*, qos_algorithm_type*, qos_algorithm_params*, locking_mode, ipv4_allowed, ipv6_allowed (* = non-optional).
func (_class VIFClass) Create(sessionID SessionRef, args VIFRecord) (_retval VIFRef, _err error) {
	if IsMock {
		return _class.CreateMock(sessionID, args)
	}	
	_method := "VIF.create"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_argsArg, _err := convertVIFRecordToXen(fmt.Sprintf("%s(%s)", _method, "args"), args)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _argsArg)
	if _err != nil {
		return
	}
	_retval, _err = convertVIFRefToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetByUUIDMockDefault(sessionID SessionRef, uuid string) (_retval VIFRef, _err error) {
	log.Println("VIF.GetByUUID not mocked")
	_err = errors.New("VIF.GetByUUID not mocked")
	return
}

var VIFClassGetByUUIDMockedCallback = VIFClassGetByUUIDMockDefault

func (_class VIFClass) GetByUUIDMock(sessionID SessionRef, uuid string) (_retval VIFRef, _err error) {
	return VIFClassGetByUUIDMockedCallback(sessionID, uuid)
}
// Get a reference to the VIF instance with the specified UUID.
func (_class VIFClass) GetByUUID(sessionID SessionRef, uuid string) (_retval VIFRef, _err error) {
	if IsMock {
		return _class.GetByUUIDMock(sessionID, uuid)
	}	
	_method := "VIF.get_by_uuid"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_uuidArg, _err := convertStringToXen(fmt.Sprintf("%s(%s)", _method, "uuid"), uuid)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _uuidArg)
	if _err != nil {
		return
	}
	_retval, _err = convertVIFRefToGo(_method + " -> ", _result.Value)
	return
}


func VIFClassGetRecordMockDefault(sessionID SessionRef, self VIFRef) (_retval VIFRecord, _err error) {
	log.Println("VIF.GetRecord not mocked")
	_err = errors.New("VIF.GetRecord not mocked")
	return
}

var VIFClassGetRecordMockedCallback = VIFClassGetRecordMockDefault

func (_class VIFClass) GetRecordMock(sessionID SessionRef, self VIFRef) (_retval VIFRecord, _err error) {
	return VIFClassGetRecordMockedCallback(sessionID, self)
}
// Get a record containing the current state of the given VIF.
func (_class VIFClass) GetRecord(sessionID SessionRef, self VIFRef) (_retval VIFRecord, _err error) {
	if IsMock {
		return _class.GetRecordMock(sessionID, self)
	}	
	_method := "VIF.get_record"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVIFRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertVIFRecordToGo(_method + " -> ", _result.Value)
	return
}