ROOT.CIMV2.Win32_OperatingSystem.cs

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

namespace CloudStack.Plugin.WmiWrappers.ROOT.CIMV2 {
    using System;
    using System.ComponentModel;
    using System.Management;
    using System.Collections;
    using System.Globalization;
    using System.ComponentModel.Design.Serialization;
    using System.Reflection;
    
    
    // Functions ShouldSerialize<PropertyName> are functions used by VS property browser to check if a particular property has to be serialized. These functions are added for all ValueType properties ( properties of type Int32, BOOL etc.. which cannot be set to null). These functions use Is<PropertyName>Null function. These functions are also used in the TypeConverter implementation for the properties to check for NULL value of property so that an empty value can be shown in Property browser in case of Drag and Drop in Visual studio.
    // Functions Is<PropertyName>Null() are used to check if a property is NULL.
    // Functions Reset<PropertyName> are added for Nullable Read/Write properties. These functions are used by VS designer in property browser to set a property to NULL.
    // Every property added to the class for WMI property has attributes set to define its behavior in Visual Studio designer and also to define a TypeConverter to be used.
    // Datetime conversion functions ToDateTime and ToDmtfDateTime are added to the class to convert DMTF datetime to System.DateTime and vice-versa.
    // An Early Bound class generated for the WMI class.Win32_OperatingSystem
    public class OperatingSystem0 : System.ComponentModel.Component {
        
        // Private property to hold the WMI namespace in which the class resides.
        private static string CreatedWmiNamespace = "ROOT\\CIMV2";
        
        // Private property to hold the name of WMI class which created this class.
        private static string CreatedClassName = "Win32_OperatingSystem";
        
        // Private member variable to hold the ManagementScope which is used by the various methods.
        private static System.Management.ManagementScope statMgmtScope = null;
        
        private ManagementSystemProperties PrivateSystemProperties;
        
        // Underlying lateBound WMI object.
        private System.Management.ManagementObject PrivateLateBoundObject;
        
        // Member variable to store the 'automatic commit' behavior for the class.
        private bool AutoCommitProp;
        
        // Private variable to hold the embedded property representing the instance.
        private System.Management.ManagementBaseObject embeddedObj;
        
        // The current WMI object used
        private System.Management.ManagementBaseObject curObj;
        
        // Flag to indicate if the instance is an embedded object.
        private bool isEmbedded;
        
        // Below are different overloads of constructors to initialize an instance of the class with a WMI object.
        public OperatingSystem0() {
            this.InitializeObject(null, new System.Management.ManagementPath(OperatingSystem0.ConstructPath()), null);
        }
        
        public OperatingSystem0(System.Management.ManagementScope mgmtScope) {
            this.InitializeObject(mgmtScope, new System.Management.ManagementPath(OperatingSystem0.ConstructPath()), null);
        }
        
        public OperatingSystem0(System.Management.ObjectGetOptions getOptions) {
            this.InitializeObject(null, new System.Management.ManagementPath(OperatingSystem0.ConstructPath()), getOptions);
        }
        
        public OperatingSystem0(System.Management.ManagementScope mgmtScope, System.Management.ObjectGetOptions getOptions) {
            this.InitializeObject(mgmtScope, new System.Management.ManagementPath(OperatingSystem0.ConstructPath()), getOptions);
        }
        
        public OperatingSystem0(System.Management.ManagementPath path) {
            this.InitializeObject(null, path, null);
        }
        
        public OperatingSystem0(System.Management.ManagementScope mgmtScope, System.Management.ManagementPath path, System.Management.ObjectGetOptions getOptions) {
            this.InitializeObject(mgmtScope, path, getOptions);
        }
        
        public OperatingSystem0(System.Management.ManagementObject theObject) {
            Initialize();
            if ((CheckIfProperClass(theObject) == true)) {
                PrivateLateBoundObject = theObject;
                PrivateSystemProperties = new ManagementSystemProperties(PrivateLateBoundObject);
                curObj = PrivateLateBoundObject;
            }
            else {
                throw new System.ArgumentException("Class name does not match.");
            }
        }
        
        public OperatingSystem0(System.Management.ManagementBaseObject theObject) {
            Initialize();
            if ((CheckIfProperClass(theObject) == true)) {
                embeddedObj = theObject;
                PrivateSystemProperties = new ManagementSystemProperties(theObject);
                curObj = embeddedObj;
                isEmbedded = true;
            }
            else {
                throw new System.ArgumentException("Class name does not match.");
            }
        }
        
        // Property returns the namespace of the WMI class.
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string OriginatingNamespace {
            get {
                return "ROOT\\CIMV2";
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string ManagementClassName {
            get {
                string strRet = CreatedClassName;
                if ((curObj != null)) {
                    if ((curObj.ClassPath != null)) {
                        strRet = ((string)(curObj["__CLASS"]));
                        if (((strRet == null) 
                                    || (strRet == string.Empty))) {
                            strRet = CreatedClassName;
                        }
                    }
                }
                return strRet;
            }
        }
        
        // Property pointing to an embedded object to get System properties of the WMI object.
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ManagementSystemProperties SystemProperties {
            get {
                return PrivateSystemProperties;
            }
        }
        
        // Property returning the underlying lateBound object.
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public System.Management.ManagementBaseObject LateBoundObject {
            get {
                return curObj;
            }
        }
        
        // ManagementScope of the object.
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public System.Management.ManagementScope Scope {
            get {
                if ((isEmbedded == false)) {
                    return PrivateLateBoundObject.Scope;
                }
                else {
                    return null;
                }
            }
            set {
                if ((isEmbedded == false)) {
                    PrivateLateBoundObject.Scope = value;
                }
            }
        }
        
        // Property to show the commit behavior for the WMI object. If true, WMI object will be automatically saved after each property modification.(ie. Put() is called after modification of a property).
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool AutoCommit {
            get {
                return AutoCommitProp;
            }
            set {
                AutoCommitProp = value;
            }
        }
        
        // The ManagementPath of the underlying WMI object.
        [Browsable(true)]
        public System.Management.ManagementPath Path {
            get {
                if ((isEmbedded == false)) {
                    return PrivateLateBoundObject.Path;
                }
                else {
                    return null;
                }
            }
            set {
                if ((isEmbedded == false)) {
                    if ((CheckIfProperClass(null, value, null) != true)) {
                        throw new System.ArgumentException("Class name does not match.");
                    }
                    PrivateLateBoundObject.Path = value;
                }
            }
        }
        
        // Public static scope property which is used by the various methods.
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public static System.Management.ManagementScope StaticScope {
            get {
                return statMgmtScope;
            }
            set {
                statMgmtScope = value;
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The BootDevice property indicates the name of the disk drive from which the Win32" +
            " operating system boots. \nExample: \\\\Device\\Harddisk0.")]
        public string BootDevice {
            get {
                return ((string)(curObj["BootDevice"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The BuildNumber property indicates the build number of the operating system.  It " +
            "can be used for more precise versioning information than product release version" +
            " numbers\nExample: 1381")]
        public string BuildNumber {
            get {
                return ((string)(curObj["BuildNumber"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The BuildType property indicates the type of build used for the operating system." +
            " Examples are retail build and checked build.")]
        public string BuildType {
            get {
                return ((string)(curObj["BuildType"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The Caption property is a short textual description (one-line string) of the obje" +
            "ct.")]
        public string Caption {
            get {
                return ((string)(curObj["Caption"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"The CodeSet property indicates the code page value used by the operating system. A code page contains a character table used by the operating system to translate strings for different languages. The American National Standards Institute (ANSI) lists values that represent defined code pages. If the operating system does not use an ANSI code page, this member will be set to 0. The CodeSet string can use up to six characters to define the code page value.
Example: 1255.")]
        public string CodeSet {
            get {
                return ((string)(curObj["CodeSet"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"The CountryCode property indicates the code for the country/regionused by the operating system. Values are based on international phone dialing prefixes (also referred to as IBM country/region codes). The CountryCode string can use up to six characters to define the country/region code value.
Example: 1 for the United States)")]
        public string CountryCode {
            get {
                return ((string)(curObj["CountryCode"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("CreationClassName indicates the name of the class or the subclass used in the cre" +
            "ation of an instance. When used with the other key properties of this class, thi" +
            "s property allows all instances of this class and its subclasses to be uniquely " +
            "identified.")]
        public string CreationClassName {
            get {
                return ((string)(curObj["CreationClassName"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("CSCreationClassName contains the scoping computer system\'s creation class name.")]
        public string CSCreationClassName {
            get {
                return ((string)(curObj["CSCreationClassName"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"The CSDVersion property contains a null-terminated string, that indicates the latest Service Pack installed on the computer system. If no Service Pack is installed, the string is NULL. For computer systems running Windows 95, this property contains a null-terminated string that provides arbitrary additional information about the operating system.
Example: Service Pack 3.")]
        public string CSDVersion {
            get {
                return ((string)(curObj["CSDVersion"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("CSName contains the scoping computer system\'s name.")]
        public string CSName {
            get {
                return ((string)(curObj["CSName"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsCurrentTimeZoneNull {
            get {
                if ((curObj["CurrentTimeZone"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("CurrentTimeZone indicates the number of minutes the operating system is offset fr" +
            "om Greenwich Mean Time. Either the number is positive, negative or zero.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public short CurrentTimeZone {
            get {
                if ((curObj["CurrentTimeZone"] == null)) {
                    return System.Convert.ToInt16(0);
                }
                return ((short)(curObj["CurrentTimeZone"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsDataExecutionPrevention_32BitApplicationsNull {
            get {
                if ((curObj["DataExecutionPrevention_32BitApplications"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("If true, indicates that 32-bit applications are running with Data Execution Preve" +
            "ntion (DEP) applied. (false if DataExecutionPrevention_Available = false)")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public bool DataExecutionPrevention_32BitApplications {
            get {
                if ((curObj["DataExecutionPrevention_32BitApplications"] == null)) {
                    return System.Convert.ToBoolean(0);
                }
                return ((bool)(curObj["DataExecutionPrevention_32BitApplications"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsDataExecutionPrevention_AvailableNull {
            get {
                if ((curObj["DataExecutionPrevention_Available"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"If true, indicates that the hardware supports Windows Data Execution Prevention (DEP) technology. DEP ensures that all memory locations are marked with a non-executable attribute unless the memory location explicitly contains executable code.  This can help mitigate certain types of buffer overrun security exploits.  If DEP is available, 64-bit applications are automatically protected.  To determine if DEP has been enabled for 32-bit applications and drivers, use the DataExecutionPrevention_ properties ")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public bool DataExecutionPrevention_Available {
            get {
                if ((curObj["DataExecutionPrevention_Available"] == null)) {
                    return System.Convert.ToBoolean(0);
                }
                return ((bool)(curObj["DataExecutionPrevention_Available"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsDataExecutionPrevention_DriversNull {
            get {
                if ((curObj["DataExecutionPrevention_Drivers"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("If true, indicates that drivers are running with Data Execution Prevention (DEP) " +
            "applied. (false if DataExecutionPrevention_Available = false)")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public bool DataExecutionPrevention_Drivers {
            get {
                if ((curObj["DataExecutionPrevention_Drivers"] == null)) {
                    return System.Convert.ToBoolean(0);
                }
                return ((bool)(curObj["DataExecutionPrevention_Drivers"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsDataExecutionPrevention_SupportPolicyNull {
            get {
                if ((curObj["DataExecutionPrevention_SupportPolicy"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"The DataExecutionPrevention_SupportPolicy indicates which one of four Data Execution Prevention (DEP) settings is applied. Each setting varies by the extent to which DEP is applied to 32-bit applications.  Note that DEP is always applied to the Windows kernel. Always On (not available in the user interface) indicates that DEP is enabled for all 32-bit applications on the machine with no exceptions. OptOut indicates DEP is on by default for all 32-bit applications and that a user or administrator must explicitly remove support for a 32-bit application by adding to an exceptions list. OptIn indicates DEP is on for a limited number of binaries, the kernel, and all Windows services but it is off by default for all 32-bit applications; a user or administrator must explicitly choose the AlwaysOn (not available in the user interface) or OptOut setting before DEP can be applied to 32-bit applications.  AlwaysOff (not available in the user interface) indicates DEP is turned off for all 32-bit applications on the machine. ")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public DataExecutionPrevention_SupportPolicyValues DataExecutionPrevention_SupportPolicy {
            get {
                if ((curObj["DataExecutionPrevention_SupportPolicy"] == null)) {
                    return ((DataExecutionPrevention_SupportPolicyValues)(System.Convert.ToInt32(4)));
                }
                return ((DataExecutionPrevention_SupportPolicyValues)(System.Convert.ToInt32(curObj["DataExecutionPrevention_SupportPolicy"])));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsDebugNull {
            get {
                if ((curObj["Debug"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"The Debug property indicates whether the operating system is a checked (debug) build. Checked builds provide error checking, argument verification, and system debugging code. Additional code in a checked binary generates a kernel debugger error message and breaks into the debugger. This helps  immediately determine the cause and location of the error. Performance suffers in the checked build due to the additional code that is executed.
Values: TRUE or FALSE, A value of TRUE indicates the debugging version of User.exe is installed.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public bool Debug {
            get {
                if ((curObj["Debug"] == null)) {
                    return System.Convert.ToBoolean(0);
                }
                return ((bool)(curObj["Debug"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The Description property provides a description of the Windows operating system. " +
            "Some user interfaces (those that allow editing of this description) limit its le" +
            "ngth to 48 characters.")]
        public string Description {
            get {
                return ((string)(curObj["Description"]));
            }
            set {
                curObj["Description"] = value;
                if (((isEmbedded == false) 
                            && (AutoCommitProp == true))) {
                    PrivateLateBoundObject.Put();
                }
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsDistributedNull {
            get {
                if ((curObj["Distributed"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Boolean indicating whether the operating system is distributed across several com" +
            "puter system nodes. If so, these nodes should be grouped as a cluster.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public bool Distributed {
            get {
                if ((curObj["Distributed"] == null)) {
                    return System.Convert.ToBoolean(0);
                }
                return ((bool)(curObj["Distributed"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsEncryptionLevelNull {
            get {
                if ((curObj["EncryptionLevel"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The EncryptionLevel property specifies if the encryption level for secure transac" +
            "tions is 40-bit, 128-bit, or n-bit encryption.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public EncryptionLevelValues EncryptionLevel {
            get {
                if ((curObj["EncryptionLevel"] == null)) {
                    return ((EncryptionLevelValues)(System.Convert.ToInt32(3)));
                }
                return ((EncryptionLevelValues)(System.Convert.ToInt32(curObj["EncryptionLevel"])));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsForegroundApplicationBoostNull {
            get {
                if ((curObj["ForegroundApplicationBoost"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"The ForegroundApplicationBoost property indicates the increase in priority given to the foreground application. On computer systems running Windows NT 4.0 and Windows 2000, application boost is implemented by giving an application more execution time slices (quantum lengths). A ForegroundApplicationBoost value of 0 indicates the system boosts the quantum length by 6; if 1, then 12; and if 2 then 18. On Windows NT 3.51 and earlier, application boost is implemented by increasing the scheduling priority. For these systems, the scheduling priority is increased by the value of this property. The default value is 2.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public ForegroundApplicationBoostValues ForegroundApplicationBoost {
            get {
                if ((curObj["ForegroundApplicationBoost"] == null)) {
                    return ((ForegroundApplicationBoostValues)(System.Convert.ToInt32(3)));
                }
                return ((ForegroundApplicationBoostValues)(System.Convert.ToInt32(curObj["ForegroundApplicationBoost"])));
            }
            set {
                if ((ForegroundApplicationBoostValues.NULL_ENUM_VALUE == value)) {
                    curObj["ForegroundApplicationBoost"] = null;
                }
                else {
                    curObj["ForegroundApplicationBoost"] = value;
                }
                if (((isEmbedded == false) 
                            && (AutoCommitProp == true))) {
                    PrivateLateBoundObject.Put();
                }
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsFreePhysicalMemoryNull {
            get {
                if ((curObj["FreePhysicalMemory"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Number of kilobytes of physical memory currently unused and available")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public ulong FreePhysicalMemory {
            get {
                if ((curObj["FreePhysicalMemory"] == null)) {
                    return System.Convert.ToUInt64(0);
                }
                return ((ulong)(curObj["FreePhysicalMemory"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsFreeSpaceInPagingFilesNull {
            get {
                if ((curObj["FreeSpaceInPagingFiles"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The total number of KBytes that can be mapped into the OperatingSystem\'s paging f" +
            "iles without causing any other pages to be swapped out. 0 indicates that there a" +
            "re no paging files.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public ulong FreeSpaceInPagingFiles {
            get {
                if ((curObj["FreeSpaceInPagingFiles"] == null)) {
                    return System.Convert.ToUInt64(0);
                }
                return ((ulong)(curObj["FreeSpaceInPagingFiles"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsFreeVirtualMemoryNull {
            get {
                if ((curObj["FreeVirtualMemory"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Number of kilobytes of virtual memory currently unused and available. For example" +
            ", this may be calculated by adding the amount of free RAM to the amount of free " +
            "paging space (i.e., adding the properties, FreePhysicalMemory and FreeSpaceInPag" +
            "ingFiles).")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public ulong FreeVirtualMemory {
            get {
                if ((curObj["FreeVirtualMemory"] == null)) {
                    return System.Convert.ToUInt64(0);
                }
                return ((ulong)(curObj["FreeVirtualMemory"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsInstallDateNull {
            get {
                if ((curObj["InstallDate"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The InstallDate property is datetime value indicating when the object was install" +
            "ed. A lack of a value does not indicate that the object is not installed.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public System.DateTime InstallDate {
            get {
                if ((curObj["InstallDate"] != null)) {
                    return ToDateTime(((string)(curObj["InstallDate"])));
                }
                else {
                    return System.DateTime.MinValue;
                }
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsLargeSystemCacheNull {
            get {
                if ((curObj["LargeSystemCache"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The LargeSystemCache property indicates whether to optimize memory for applicatio" +
            "ns (value=0) or for system performance (value=1).")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public LargeSystemCacheValues LargeSystemCache {
            get {
                if ((curObj["LargeSystemCache"] == null)) {
                    return ((LargeSystemCacheValues)(System.Convert.ToInt32(2)));
                }
                return ((LargeSystemCacheValues)(System.Convert.ToInt32(curObj["LargeSystemCache"])));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsLastBootUpTimeNull {
            get {
                if ((curObj["LastBootUpTime"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Time when the operating system was last booted")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public System.DateTime LastBootUpTime {
            get {
                if ((curObj["LastBootUpTime"] != null)) {
                    return ToDateTime(((string)(curObj["LastBootUpTime"])));
                }
                else {
                    return System.DateTime.MinValue;
                }
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsLocalDateTimeNull {
            get {
                if ((curObj["LocalDateTime"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Operating system\'s notion of the local date and time of day.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public System.DateTime LocalDateTime {
            get {
                if ((curObj["LocalDateTime"] != null)) {
                    return ToDateTime(((string)(curObj["LocalDateTime"])));
                }
                else {
                    return System.DateTime.MinValue;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"The Locale property indicates the language identifier used by the operating system. A language identifier is a standard international numeric abbreviation for a country or region. Each language has a unique language identifier (LANGID), a 16-bit value that consists of a primary language identifier and a secondary language identifier.")]
        public string Locale {
            get {
                return ((string)(curObj["Locale"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The Manufacturer property indicates the name of the operating system manufacturer" +
            ".  For Win32 systems this value will be Microsoft Corporation.")]
        public string Manufacturer {
            get {
                return ((string)(curObj["Manufacturer"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsMaxNumberOfProcessesNull {
            get {
                if ((curObj["MaxNumberOfProcesses"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"Maximum number of process contexts the operating system can support. If there is no fixed maximum, the value should be 0. On systems that have a fixed maximum, this object can help diagnose failures that occur when the maximum is reached. If unknown, enter -1.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public uint MaxNumberOfProcesses {
            get {
                if ((curObj["MaxNumberOfProcesses"] == null)) {
                    return System.Convert.ToUInt32(0);
                }
                return ((uint)(curObj["MaxNumberOfProcesses"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsMaxProcessMemorySizeNull {
            get {
                if ((curObj["MaxProcessMemorySize"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description(@"Maximum number of kilobytes of memory that can be allocated to a process. For operating systems with no virtual memory, this value is typically equal to the total amount of physical memory minus memory used by the BIOS and OS. For some operating systems, this value may be infinity - in which case, 0 should be entered. In other cases, this value could be a constant - for example, 2G or 4G.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public ulong MaxProcessMemorySize {
            get {
                if ((curObj["MaxProcessMemorySize"] == null)) {
                    return System.Convert.ToUInt64(0);
                }
                return ((ulong)(curObj["MaxProcessMemorySize"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The MUILanguages property indicates the MUI Languages installed in the system. \n " +
            "Example: en-us.")]
        public string[] MUILanguages {
            get {
                return ((string[])(curObj["MUILanguages"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Name of the operating system instance within a computer system.")]
        public string Name {
            get {
                return ((string)(curObj["Name"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsNumberOfLicensedUsersNull {
            get {
                if ((curObj["NumberOfLicensedUsers"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Number of user licenses for the operating system. If unlimited, enter 0. If unkno" +
            "wn, enter -1.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public uint NumberOfLicensedUsers {
            get {
                if ((curObj["NumberOfLicensedUsers"] == null)) {
                    return System.Convert.ToUInt32(0);
                }
                return ((uint)(curObj["NumberOfLicensedUsers"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsNumberOfProcessesNull {
            get {
                if ((curObj["NumberOfProcesses"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Number of process contexts currently loaded or running on the operating system.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public uint NumberOfProcesses {
            get {
                if ((curObj["NumberOfProcesses"] == null)) {
                    return System.Convert.ToUInt32(0);
                }
                return ((uint)(curObj["NumberOfProcesses"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsNumberOfUsersNull {
            get {
                if ((curObj["NumberOfUsers"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Number of user sessions for which the operating system is currently storing state" +
            " information")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public uint NumberOfUsers {
            get {
                if ((curObj["NumberOfUsers"] == null)) {
                    return System.Convert.ToUInt32(0);
                }
                return ((uint)(curObj["NumberOfUsers"]));
            }
        }
        
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsOperatingSystemSKUNull {
            get {
                if ((curObj["OperatingSystemSKU"] == null)) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The OperatingSystemSKU property identifies the SKU of the operating system.")]
        [TypeConverter(typeof(WMIValueTypeConverter))]
        public uint OperatingSystemSKU {
            get {
                if ((curObj["OperatingSystemSKU"] == null)) {
                    return System.Convert.ToUInt32(0);
                }
                return ((uint)(curObj["OperatingSystemSKU"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The Organization property indicates the registered user\'s (of the operating syste" +
            "m) company name.\nExample: Microsoft Corporation.")]
        public string Organization {
            get {
                return ((string)(curObj["Organization"]));
            }
        }
        
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("The OSArchitecture property indicates the Architecture of the operating system.Ex" +
            "ample: 32-bit, 64-bit Intel, 64-bit AMD ")]
        public string OSArchitecture {
            get {
                return ((string)(curObj["OSArchitecture"]));
            }