/* * Copyright (c) Citrix Systems, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1) Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2) Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. */ using System; using System.Collections; using System.Collections.Generic; namespace XenAPI { /// /// A virtual TPM device /// First published in XenServer 4.0. /// public partial class VTPM : XenObject { public VTPM() { } public VTPM(string uuid, XenRef VM, XenRef backend) { this.uuid = uuid; this.VM = VM; this.backend = backend; } /// /// Creates a new VTPM from a Proxy_VTPM. /// /// public VTPM(Proxy_VTPM proxy) { this.UpdateFromProxy(proxy); } public override void UpdateFrom(VTPM update) { uuid = update.uuid; VM = update.VM; backend = update.backend; } internal void UpdateFromProxy(Proxy_VTPM proxy) { uuid = proxy.uuid == null ? null : (string)proxy.uuid; VM = proxy.VM == null ? null : XenRef.Create(proxy.VM); backend = proxy.backend == null ? null : XenRef.Create(proxy.backend); } public Proxy_VTPM ToProxy() { Proxy_VTPM result_ = new Proxy_VTPM(); result_.uuid = uuid ?? ""; result_.VM = VM ?? ""; result_.backend = backend ?? ""; return result_; } /// /// Creates a new VTPM from a Hashtable. /// /// public VTPM(Hashtable table) { uuid = Marshalling.ParseString(table, "uuid"); VM = Marshalling.ParseRef(table, "VM"); backend = Marshalling.ParseRef(table, "backend"); } public bool DeepEquals(VTPM other) { if (ReferenceEquals(null, other)) return false; if (ReferenceEquals(this, other)) return true; return Helper.AreEqual2(this._uuid, other._uuid) && Helper.AreEqual2(this._VM, other._VM) && Helper.AreEqual2(this._backend, other._backend); } internal static List ProxyArrayToObjectList(Proxy_VTPM[] input) { var result = new List(); foreach (var item in input) result.Add(new VTPM(item)); return result; } public override string SaveChanges(Session session, string opaqueRef, VTPM server) { if (opaqueRef == null) { Proxy_VTPM p = this.ToProxy(); return session.proxy.vtpm_create(session.uuid, p).parse(); } else { throw new InvalidOperationException("This type has no read/write properties"); } } /// /// Get a record containing the current state of the given VTPM. /// First published in XenServer 4.0. /// /// The session /// The opaque_ref of the given vtpm public static VTPM get_record(Session session, string _vtpm) { return new VTPM((Proxy_VTPM)session.proxy.vtpm_get_record(session.uuid, _vtpm ?? "").parse()); } /// /// Get a reference to the VTPM instance with the specified UUID. /// First published in XenServer 4.0. /// /// The session /// UUID of object to return public static XenRef get_by_uuid(Session session, string _uuid) { return XenRef.Create(session.proxy.vtpm_get_by_uuid(session.uuid, _uuid ?? "").parse()); } /// /// Create a new VTPM instance, and return its handle. /// First published in XenServer 4.0. /// /// The session /// All constructor arguments public static XenRef create(Session session, VTPM _record) { return XenRef.Create(session.proxy.vtpm_create(session.uuid, _record.ToProxy()).parse()); } /// /// Create a new VTPM instance, and return its handle. /// First published in XenServer 4.0. /// /// The session /// All constructor arguments public static XenRef async_create(Session session, VTPM _record) { return XenRef.Create(session.proxy.async_vtpm_create(session.uuid, _record.ToProxy()).parse()); } /// /// Destroy the specified VTPM instance. /// First published in XenServer 4.0. /// /// The session /// The opaque_ref of the given vtpm public static void destroy(Session session, string _vtpm) { session.proxy.vtpm_destroy(session.uuid, _vtpm ?? "").parse(); } /// /// Destroy the specified VTPM instance. /// First published in XenServer 4.0. /// /// The session /// The opaque_ref of the given vtpm public static XenRef async_destroy(Session session, string _vtpm) { return XenRef.Create(session.proxy.async_vtpm_destroy(session.uuid, _vtpm ?? "").parse()); } /// /// Get the uuid field of the given VTPM. /// First published in XenServer 4.0. /// /// The session /// The opaque_ref of the given vtpm public static string get_uuid(Session session, string _vtpm) { return (string)session.proxy.vtpm_get_uuid(session.uuid, _vtpm ?? "").parse(); } /// /// Get the VM field of the given VTPM. /// First published in XenServer 4.0. /// /// The session /// The opaque_ref of the given vtpm public static XenRef get_VM(Session session, string _vtpm) { return XenRef.Create(session.proxy.vtpm_get_vm(session.uuid, _vtpm ?? "").parse()); } /// /// Get the backend field of the given VTPM. /// First published in XenServer 4.0. /// /// The session /// The opaque_ref of the given vtpm public static XenRef get_backend(Session session, string _vtpm) { return XenRef.Create(session.proxy.vtpm_get_backend(session.uuid, _vtpm ?? "").parse()); } /// /// Unique identifier/object reference /// public virtual string uuid { get { return _uuid; } set { if (!Helper.AreEqual(value, _uuid)) { _uuid = value; Changed = true; NotifyPropertyChanged("uuid"); } } } private string _uuid; /// /// the virtual machine /// public virtual XenRef VM { get { return _VM; } set { if (!Helper.AreEqual(value, _VM)) { _VM = value; Changed = true; NotifyPropertyChanged("VM"); } } } private XenRef _VM; /// /// the domain where the backend is located /// public virtual XenRef backend { get { return _backend; } set { if (!Helper.AreEqual(value, _backend)) { _backend = value; Changed = true; NotifyPropertyChanged("backend"); } } } private XenRef _backend; } }