/**
  *
  * WMI
  * @author Thomas Sparber (2016)
  *
 **/

#ifndef WMICLASSES_HPP
#define WMICLASSES_HPP

#include <string>

#include <wmi.hpp>
#include <wmiresult.hpp>

namespace Wmi
{
struct Win32_ComputerSystemProduct
{

 Win32_ComputerSystemProduct():
	Caption(),
	Description(),
	IdentifyingNumber(),
	Name(),
	UUID(),
	Vendor(),
	Version()
	{ }
void setProperties(const WmiResult &result, std::size_t index){

	result.extract(index,"Caption",(*this).Caption);
		result.extract(index,"Description",(*this).Description);
			result.extract(index,"IdentifyingNumber",(*this).IdentifyingNumber);
				result.extract(index,"Name",(*this).Name);
				result.extract(index,"UUID",(*this).UUID);
				result.extract(index,"Vendor",(*this).Vendor);
				result.extract(index,"Version",(*this).Version);

}

	static std::string getWmiClassName()
	{
		return "Win32_ComputerSystemProduct";
	}

	std::string Caption;
	std::string Description;
	std::string IdentifyingNumber;
	std::string Name;
	std::string UUID;
    std::string Vendor;
    std::string Version;
};

struct Win32_ComputerSystem
{

	Win32_ComputerSystem() :
		AdminPasswordStatus(), AutomaticManagedPagefile(), AutomaticResetBootOption(), AutomaticResetCapability(),
		BootOptionOnLimit(), BootOptionOnWatchDog(), BootROMSupported(), BootupState(), Caption(), ChassisBootupState(),
		CreationClassName(), CurrentTimeZone(), DaylightInEffect(), Description(), DNSHostName(), Domain(), DomainRole(),
		EnableDaylightSavingsTime(), FrontPanelResetStatus(), InfraredSupported(), InitialLoadInfo(), InstallDate(),
		KeyboardPasswordStatus(), LastLoadInfo(), Manufacturer(), Model(), Name(), NameFormat(), NetworkServerModeEnabled(),
		NumberOfLogicalProcessors(), NumberOfProcessors(), OEMLogoBitmap(), OEMStringArray(), PartOfDomain(),
		PauseAfterReset(), PCSystemType(), PowerManagementCapabilities(), PowerManagementSupported(),
		PowerOnPasswordStatus(), PowerState(), PowerSupplyState(), PrimaryOwnerContact(), PrimaryOwnerName(),
		ResetCapability(), ResetCount(), ResetLimit(), Roles(), Status(), SupportContactDescription(), SystemStartupDelay(),
		SystemStartupOptions(), SystemStartupSetting(), SystemType(), ThermalState(), TotalPhysicalMemory(), UserName(),
		WakeUpType(), Workgroup()
	{}

	void setProperties(const WmiResult &result, std::size_t index)
	{

		result.extract(index,"AdminPasswordStatus",(*this).AdminPasswordStatus);
		result.extract(index,"AutomaticManagedPagefile",(*this).AutomaticManagedPagefile);
		result.extract(index,"AutomaticResetBootOption",(*this).AutomaticResetBootOption);
		result.extract(index,"AutomaticResetCapability",(*this).AutomaticResetCapability);
		result.extract(index,"BootOptionOnLimit",(*this).BootOptionOnLimit);
		result.extract(index,"BootOptionOnWatchDog",(*this).BootOptionOnWatchDog);
		result.extract(index,"BootROMSupported",(*this).BootROMSupported);
		result.extract(index,"BootupState",(*this).BootupState);
		result.extract(index,"Caption",(*this).Caption);
		result.extract(index,"ChassisBootupState",(*this).ChassisBootupState);
		result.extract(index,"CreationClassName",(*this).CreationClassName);
		result.extract(index,"CurrentTimeZone",(*this).CurrentTimeZone);
		result.extract(index,"DaylightInEffect",(*this).DaylightInEffect);
		result.extract(index,"Description",(*this).Description);
		result.extract(index,"DNSHostName",(*this).DNSHostName);
		result.extract(index,"Domain",(*this).Domain);
		result.extract(index,"DomainRole",(*this).DomainRole);
		result.extract(index,"EnableDaylightSavingsTime",(*this).EnableDaylightSavingsTime);
		result.extract(index,"FrontPanelResetStatus",(*this).FrontPanelResetStatus);
		result.extract(index,"InfraredSupported",(*this).InfraredSupported);
		result.extract(index,"InitialLoadInfo",(*this).InitialLoadInfo);
		result.extract(index,"InstallDate",(*this).InstallDate);
		result.extract(index,"KeyboardPasswordStatus",(*this).KeyboardPasswordStatus);
		result.extract(index,"LastLoadInfo",(*this).LastLoadInfo);
		result.extract(index,"Manufacturer",(*this).Manufacturer);
		result.extract(index,"Model",(*this).Model);
		result.extract(index,"Name",(*this).Name);
		result.extract(index,"NameFormat",(*this).NameFormat);
		result.extract(index,"NetworkServerModeEnabled",(*this).NetworkServerModeEnabled);
		result.extract(index,"NumberOfLogicalProcessors",(*this).NumberOfLogicalProcessors);
		result.extract(index,"NumberOfProcessors",(*this).NumberOfProcessors);
		result.extract(index,"OEMLogoBitmap",(*this).OEMLogoBitmap);
		result.extract(index,"OEMStringArray",(*this).OEMStringArray);
		result.extract(index,"PartOfDomain",(*this).PartOfDomain);
		result.extract(index,"PauseAfterReset",(*this).PauseAfterReset);
		result.extract(index,"PCSystemType",(*this).PCSystemType);
		result.extract(index,"PowerManagementCapabilities",(*this).PowerManagementCapabilities);
		result.extract(index,"PowerManagementSupported",(*this).PowerManagementSupported);
		result.extract(index,"PowerOnPasswordStatus",(*this).PowerOnPasswordStatus);
		result.extract(index,"PowerState",(*this).PowerState);
		result.extract(index,"PowerSupplyState",(*this).PowerSupplyState);
		result.extract(index,"PrimaryOwnerContact",(*this).PrimaryOwnerContact);
		result.extract(index,"PrimaryOwnerName",(*this).PrimaryOwnerName);
		result.extract(index,"ResetCapability",(*this).ResetCapability);
		result.extract(index,"ResetCount",(*this).ResetCount);
		result.extract(index,"ResetLimit",(*this).ResetLimit);
		result.extract(index,"Roles",(*this).Roles);
		result.extract(index,"Status",(*this).Status);
		result.extract(index,"SupportContactDescription",(*this).SupportContactDescription);
		result.extract(index,"SystemStartupDelay",(*this).SystemStartupDelay);
		result.extract(index,"SystemStartupOptions",(*this).SystemStartupOptions);
		result.extract(index,"SystemStartupSetting",(*this).SystemStartupSetting);
		result.extract(index,"SystemType",(*this).SystemType);
		result.extract(index,"ThermalState",(*this).ThermalState);
		result.extract(index,"TotalPhysicalMemory",(*this).TotalPhysicalMemory);
		result.extract(index,"UserName",(*this).UserName);
		result.extract(index,"WakeUpType",(*this).WakeUpType);
		result.extract(index,"Workgroup",(*this).Workgroup);
	}

	static std::string getWmiClassName()
	{
		return "Win32_ComputerSystem";
	}

	int AdminPasswordStatus;
	bool AutomaticManagedPagefile;
	bool AutomaticResetBootOption;
	bool AutomaticResetCapability;
	std::string BootOptionOnLimit;
	std::string BootOptionOnWatchDog;
	bool BootROMSupported;
	std::string BootupState;
	std::string Caption;
	int ChassisBootupState;
	std::string CreationClassName;
	int CurrentTimeZone;
	bool DaylightInEffect;
	std::string Description;
	std::string DNSHostName;
	std::string Domain;
	int DomainRole;
	bool EnableDaylightSavingsTime;
	int FrontPanelResetStatus;
	bool InfraredSupported;
	std::string InitialLoadInfo;
	std::string InstallDate;
	int KeyboardPasswordStatus;
	std::string LastLoadInfo;
	std::string Manufacturer;
	std::string Model;
	std::string Name;
	std::string NameFormat;
	bool NetworkServerModeEnabled;
	int NumberOfLogicalProcessors;
	int NumberOfProcessors;
	std::string OEMLogoBitmap;
	std::string OEMStringArray;
	bool PartOfDomain;
	int PauseAfterReset;
	int PCSystemType;
	std::string PowerManagementCapabilities;
	std::string PowerManagementSupported;
	int PowerOnPasswordStatus;
	int PowerState;
	int PowerSupplyState;
	std::string PrimaryOwnerContact;
	std::string PrimaryOwnerName;
	int ResetCapability;
	int ResetCount;
	int ResetLimit;
	std::vector<std::string> Roles;
	std::string Status;
	std::string SupportContactDescription;
	std::string SystemStartupDelay;
	std::string SystemStartupOptions;
	std::string SystemStartupSetting;
	std::string SystemType;
	int ThermalState;
	uint64_t TotalPhysicalMemory;
	std::string UserName;
	int WakeUpType;
	std::string Workgroup;

}; //end struct Win32_ComputerSystem

struct Win32_ParallelPort
{

	Win32_ParallelPort() :
		Availability(), Capabilities(), CapabilityDescriptions(), Caption(), ConfigManagerErrorCode(),
		ConfigManagerUserConfig(), CreationClassName(), Description(), DeviceID(), DMASupport(), ErrorCleared(),
		ErrorDescription(), InstallDate(), LastErrorCode(), MaxNumberControlled(), Name(), OSAutoDiscovered(),
		PNPDeviceID(), PowerManagementCapabilities(), PowerManagementSupported(), ProtocolSupported(), Status(),
		StatusInfo(), SystemCreationClassName(), SystemName(), TimeOfLastReset()
	{}

	void setProperties(const WmiResult &result, std::size_t index)
	{
		//vscode was a great help with search(.+?), 
		//and replace result.extract(index, "$1", (*this).$1);
		result.extract(index,"Availability",(*this).Availability);
		result.extract(index,"Capabilities",(*this).Capabilities);
		result.extract(index,"CapabilityDescriptions",(*this).CapabilityDescriptions);
		result.extract(index,"Caption",(*this).Caption);
		result.extract(index,"ConfigManagerErrorCode",(*this).ConfigManagerErrorCode);
		result.extract(index,"ConfigManagerUserConfig",(*this).ConfigManagerUserConfig);
		result.extract(index,"CreationClassName",(*this).CreationClassName);
		result.extract(index,"Description",(*this).Description);
		result.extract(index,"DeviceID",(*this).DeviceID);
		result.extract(index,"DMASupport",(*this).DMASupport);
		result.extract(index,"ErrorCleared",(*this).ErrorCleared);
		result.extract(index,"ErrorDescription",(*this).ErrorDescription);
		result.extract(index,"InstallDate",(*this).InstallDate);
		result.extract(index,"LastErrorCode",(*this).LastErrorCode);
		result.extract(index,"MaxNumberControlled",(*this).MaxNumberControlled);
		result.extract(index,"Name",(*this).Name);
		result.extract(index,"OSAutoDiscovered",(*this).OSAutoDiscovered);
		result.extract(index,"PNPDeviceID",(*this).PNPDeviceID);
		result.extract(index,"PowerManagementCapabilities",(*this).PowerManagementCapabilities);
		result.extract(index,"PowerManagementSupported",(*this).PowerManagementSupported);
		result.extract(index,"ProtocolSupported",(*this).ProtocolSupported);
		result.extract(index,"Status",(*this).Status);
		result.extract(index,"StatusInfo",(*this).StatusInfo);
		result.extract(index,"SystemCreationClassName",(*this).SystemCreationClassName);
		result.extract(index,"SystemName",(*this).SystemName);
		result.extract(index,"TimeOfLastReset",(*this).TimeOfLastReset);
		
	}

	static std::string getWmiClassName()
	{
		return "Win32_ParallelPort";
	}
	
	int Availability;
	std::string Capabilities;
	std::string CapabilityDescriptions;
	std::string Caption;
	int ConfigManagerErrorCode;
	bool ConfigManagerUserConfig;
	std::string CreationClassName;
	std::string Description;
	std::string DeviceID;
	bool DMASupport;
	std::string ErrorCleared;
	std::string ErrorDescription;
	std::string InstallDate;
	int LastErrorCode;
	int MaxNumberControlled;
	std::string Name;
	bool OSAutoDiscovered;
	std::string PNPDeviceID;
	std::string PowerManagementCapabilities;
	bool PowerManagementSupported;
	int ProtocolSupported;
	std::string Status;
	std::string StatusInfo;
	std::string SystemCreationClassName;
	std::string SystemName;
	std::string TimeOfLastReset;

}; //end class Win32_ParallelPort

struct Win32_PhysicalMedia
{
	Win32_PhysicalMedia() :
		Caption(), Description(), InstallDate(), Name(), Status(), CreationClassName(),
		Manufacturer(), Model(), SKU(), SerialNumber(), Tag(), Version(), PartNumber(),
		OtherIdentifyingInfo(), PoweredOn(), Removable(), Replaceable(), HotSwappable(),
		Capacity(), MediaType(), MediaDescription(), WriteProtectOn(), CleanerMedia()
	{}

	void setProperties(const WmiResult& result, std::size_t index)
	{
		result.extract(index, "Caption", (*this).Caption);
		result.extract(index, "Description", (*this).Description);
		result.extract(index, "InstallDate", (*this).InstallDate);
		result.extract(index, "Name", (*this).Name);
		result.extract(index, "Status", (*this).Status);
		result.extract(index, "CreationClassName", (*this).CreationClassName);
		result.extract(index, "Manufacturer", (*this).Manufacturer);
		result.extract(index, "Model", (*this).Model);
		result.extract(index, "SKU", (*this).SKU);
		result.extract(index, "SerialNumber", (*this).SerialNumber);
		result.extract(index, "Tag", (*this).Tag);
		result.extract(index, "Version", (*this).Version);
		result.extract(index, "PartNumber", (*this).PartNumber);
		result.extract(index, "OtherIdentifyingInfo", (*this).OtherIdentifyingInfo);
		result.extract(index, "PoweredOn", (*this).Removable);
		result.extract(index, "Replaceable", (*this).Replaceable);
		result.extract(index, "HotSwappable", (*this).HotSwappable);
		result.extract(index, "Capacity", (*this).Capacity);
		result.extract(index, "MediaType", (*this).MediaType);
		result.extract(index, "MediaDescription", (*this).MediaDescription);
		result.extract(index, "WriteProtectOn", (*this).WriteProtectOn);
		result.extract(index, "CleanerMedia", (*this).CleanerMedia);
	}

	static std::string getWmiClassName()
	{
		return "Win32_PhysicalMedia";
	}

	std::string Caption;
	std::string Description;
	std::string InstallDate;
	std::string Name;
	std::string Status;
	std::string CreationClassName;
	std::string Manufacturer;
	std::string Model;
	std::string SKU;
	std::string SerialNumber;
	std::string Tag;
	std::string Version;
	std::string PartNumber;
	std::string OtherIdentifyingInfo;
	bool PoweredOn;
	bool Removable;
	bool Replaceable;
	bool HotSwappable;
	std::string Capacity;
	int MediaType;
	std::string MediaDescription;
	bool WriteProtectOn;
	bool CleanerMedia;

}; //end class Win32_PhysicalMedia

struct Win32_Processor
{
	Win32_Processor() :
		AddressWidth(), Architecture(), AssetTag(), Availability(), Caption(), Characteristics(), ConfigManagerErrorCode(),
		ConfigManagerUserConfig(), CpuStatus(), CreationClassName(), CurrentClockSpeed(), CurrentVoltage(), DataWidth(),
		Description(), DeviceID(), ErrorCleared(), ErrorDescription(), ExtClock(), Family(), InstallDate(),
		L2CacheSize(), L2CacheSpeed(), L3CacheSize(), L3CacheSpeed(), LastErrorCode(), Level(), LoadPercentage(),
		Manufacturer(), MaxClockSpeed(), Name(), NumberOfCores(), NumberOfEnabledCore(), NumberOfLogicalProcessors(),
		OtherFamilyDescription(), PartNumber(), PNPDeviceID(), PowerManagementCapabilities(), PowerManagementSupported(), ProcessorId(),
		ProcessorType(), Revision(), Role(), SecondLevelAddressTranslationExtensions(), SerialNumber(), SocketDesignation(),
		Status(), StatusInfo(), Stepping(), SystemCreationClassName(), SystemName(), ThreadCount(), UniqueId(),
		UpgradeMethod(), Version(), VirtualizationFirmwareEnabled(), VMMonitorModeExtensions(), VoltageCaps()
	{}

	void setProperties(const WmiResult& result, std::size_t index)
	{
		//vscode was a great help with search(.+?), 
		//and replace result.extract(index, "$1", (*this).$1);
		result.extract(index, "AddressWidth", (*this).AddressWidth);
		result.extract(index, "Architecture", (*this).Architecture);
		result.extract(index, "AssetTag", (*this).AssetTag);
		result.extract(index, "Availability", (*this).Availability);
		result.extract(index, "Caption", (*this).Caption);
		result.extract(index, "Characteristics", (*this).Characteristics);
		result.extract(index, "ConfigManagerErrorCode", (*this).ConfigManagerErrorCode);
		result.extract(index, "ConfigManagerUserConfig", (*this).ConfigManagerUserConfig);
		result.extract(index, "CpuStatus", (*this).CpuStatus);
		result.extract(index, "CreationClassName", (*this).CreationClassName);
		result.extract(index, "CurrentClockSpeed", (*this).CurrentClockSpeed);
		result.extract(index, "CurrentVoltage", (*this).CurrentVoltage);
		result.extract(index, "DataWidth", (*this).DataWidth);
		result.extract(index, "Description", (*this).Description);
		result.extract(index, "DeviceID", (*this).DeviceID);
		result.extract(index, "ErrorCleared", (*this).ErrorCleared);
		result.extract(index, "ErrorDescription", (*this).ErrorDescription);
		result.extract(index, "ExtClock", (*this).ExtClock);
		result.extract(index, "Family", (*this).Family);
		result.extract(index, "InstallDate", (*this).InstallDate);
		result.extract(index, "L2CacheSize", (*this).L2CacheSize);
		result.extract(index, "L2CacheSpeed", (*this).L2CacheSpeed);
		result.extract(index, "L3CacheSize", (*this).L3CacheSize);
		result.extract(index, "L3CacheSpeed", (*this).L3CacheSpeed);
		result.extract(index, "LastErrorCode", (*this).LastErrorCode);
		result.extract(index, "Level", (*this).Level);
		result.extract(index, "LoadPercentage", (*this).LoadPercentage);
		result.extract(index, "Manufacturer", (*this).Manufacturer);
		result.extract(index, "MaxClockSpeed", (*this).MaxClockSpeed);
		result.extract(index, "Name", (*this).Name);
		result.extract(index, "NumberOfCores", (*this).NumberOfCores);
		result.extract(index, "NumberOfEnabledCore", (*this).NumberOfEnabledCore);
		result.extract(index, "NumberOfLogicalProcessors", (*this).NumberOfLogicalProcessors);
		result.extract(index, "OtherFamilyDescription", (*this).OtherFamilyDescription);
		result.extract(index, "PartNumber", (*this).PartNumber);
		result.extract(index, "PNPDeviceID", (*this).PNPDeviceID);
		result.extract(index, "PowerManagementCapabilities", (*this).PowerManagementCapabilities);
		result.extract(index, "PowerManagementSupported", (*this).PowerManagementSupported);
		result.extract(index, "ProcessorId", (*this).ProcessorId);
		result.extract(index, "ProcessorType", (*this).ProcessorType);
		result.extract(index, "Revision", (*this).Revision);
		result.extract(index, "SecondLevelAddressTranslationExtensions", (*this).SecondLevelAddressTranslationExtensions);
		result.extract(index, "SerialNumber", (*this).SerialNumber);
		result.extract(index, "SocketDesignation", (*this).SocketDesignation);
		result.extract(index, "Status", (*this).Status);
		result.extract(index, "StatusInfo", (*this).StatusInfo);
		result.extract(index, "Stepping", (*this).Stepping);
		result.extract(index, "SystemCreationClassName", (*this).SystemCreationClassName);
		result.extract(index, "SystemName", (*this).SystemName);
		result.extract(index, "ThreadCount", (*this).ThreadCount);
		result.extract(index, "UniqueId", (*this).UniqueId);
		result.extract(index, "UpgradeMethod", (*this).UpgradeMethod);
		result.extract(index, "Version", (*this).Version);
		result.extract(index, "VirtualizationFirmwareEnabled", (*this).VirtualizationFirmwareEnabled);
		result.extract(index, "VMMonitorModeExtensions", (*this).VMMonitorModeExtensions);
		result.extract(index, "VoltageCaps", (*this).VoltageCaps);
	}

	static std::string getWmiClassName()
	{
		return "Win32_Processor";
	}

	int AddressWidth;
	int Architecture;
	std::string AssetTag;
	int Availability;
	std::string Caption;
	std::string Characteristics;
	int ConfigManagerErrorCode;
	bool ConfigManagerUserConfig;
	int CpuStatus;
	std::string CreationClassName;
	int CurrentClockSpeed;
	int CurrentVoltage;
	int DataWidth;
	std::string Description;
	std::string DeviceID;
	std::string ErrorCleared;
	std::string ErrorDescription;
	int ExtClock;
	int Family;
	std::string InstallDate;
	int L2CacheSize;
	int L2CacheSpeed;
	int L3CacheSize;
	int L3CacheSpeed;
	int LastErrorCode;
	int Level;
	int LoadPercentage;
	std::string Manufacturer;
	int MaxClockSpeed;
	std::string Name;
	int NumberOfCores;
	int NumberOfEnabledCore;
	int NumberOfLogicalProcessors;
	std::string OtherFamilyDescription;
	std::string PartNumber;
	std::string PNPDeviceID;
	std::string PowerManagementCapabilities;
	bool PowerManagementSupported;
	std::string ProcessorId;
	int ProcessorType;
	int Revision;
	std::string Role;
	bool SecondLevelAddressTranslationExtensions;
	std::string SerialNumber;
	std::string SocketDesignation;
	std::string Status;
	std::string StatusInfo;
	std::string Stepping;
	std::string SystemCreationClassName;
	std::string SystemName;
	std::string ThreadCount;
	std::string UniqueId;
	int UpgradeMethod;
	std::string Version;
	bool VirtualizationFirmwareEnabled;
	bool VMMonitorModeExtensions;
	int VoltageCaps;

}; //end class Win32_Processor

struct Win32_Service
{

	Win32_Service() :
		AcceptPause(), AcceptStop(), Caption(), CheckPoint(), CreationClassName(), Description(),
		DesktopInteract(), DisplayName(), ErrorControl(), ExitCode(), InstallDate(), Name(), PathName(),
		ProcessId(), ServiceSpecificExitCode(), ServiceType(), Started(), StartMode(), StartName(), State(),
		Status(), SystemCreationClassName(), SystemName(), TagId(), WaitHint()
	{}

	void setProperties(const WmiResult &result, std::size_t index)
	{
		result.extract(index, "AcceptPause", (*this).AcceptPause);
		result.extract(index, "AcceptStop", (*this).AcceptStop);
		result.extract(index, "Caption", (*this).Caption);
		result.extract(index, "CheckPoint", (*this).CheckPoint);
		result.extract(index, "CreationClassName", (*this).CreationClassName);
		result.extract(index, "Description", (*this).Description);
		result.extract(index, "DesktopInteract", (*this).DesktopInteract);
		result.extract(index, "DisplayName", (*this).DisplayName);
		result.extract(index, "ErrorControl", (*this).ErrorControl);
		result.extract(index, "ExitCode", (*this).ExitCode);
		result.extract(index, "InstallDate", (*this).InstallDate);
		result.extract(index, "Name", (*this).Name);
		result.extract(index, "PathName", (*this).PathName);
		result.extract(index, "ProcessId", (*this).ProcessId);
		result.extract(index, "ServiceSpecificExitCode", (*this).ServiceSpecificExitCode);
		result.extract(index, "ServiceType", (*this).ServiceType);
		result.extract(index, "Started", (*this).Started);
		result.extract(index, "StartMode", (*this).StartMode);
		result.extract(index, "StartName", (*this).StartName);
		result.extract(index, "State", (*this).State);
		result.extract(index, "Status", (*this).Status);
		result.extract(index, "SystemCreationClassName", (*this).SystemCreationClassName);
		result.extract(index, "SystemName", (*this).SystemName);
		result.extract(index, "TagId", (*this).TagId);
		result.extract(index, "WaitHint", (*this).WaitHint);
	}

	static std::string getWmiClassName()
	{
		return "Win32_Service";
	}
	
	bool AcceptPause;
	bool AcceptStop;
	std::string Caption;
	int CheckPoint;
	std::string CreationClassName;
	std::string Description;
	bool DesktopInteract;
	std::string DisplayName;
	std::string ErrorControl;
	int ExitCode;
	std::string InstallDate;
	std::string Name;
	std::string PathName;
	int ProcessId;
	int ServiceSpecificExitCode;
	std::string ServiceType;
	bool Started;
	std::string StartMode;
	std::string StartName;
	std::string State;
	std::string Status;
	std::string SystemCreationClassName;
	std::string SystemName;
	int TagId;
	int WaitHint;

}; //end Win32_Service

struct Win32_SerialPort
{

	Win32_SerialPort() :
		Availability(), Binary(), Capabilities(), CapabilityDescriptions(), Caption(),
		ConfigManagerErrorCode(), ConfigManagerUserConfig(), CreationClassName(), Description(),
		DeviceID(), ErrorCleared(), ErrorDescription(), InstallDate(), LastErrorCode(), MaxBaudRate(),
		MaximumInputBufferSize(), MaximumOutputBufferSize(), MaxNumberControlled(), Name(),
		OSAutoDiscovered(), PNPDeviceID(), PowerManagementCapabilities(), PowerManagementSupported(),
		ProtocolSupported(), ProviderType(), SettableBaudRate(), SettableDataBits(),
		SettableFlowControl(), SettableParity(), SettableParityCheck(), SettableRLSD(),
		SettableStopBits(), Status(), StatusInfo(), Supports16BitMode(), SupportsDTRDSR(),
		SupportsElapsedTimeouts(), SupportsIntTimeouts(), SupportsParityCheck(), SupportsRLSD(),
		SupportsRTSCTS(), SupportsSpecialCharacters(), SupportsXOnXOff(), SupportsXOnXOffSet(),
		SystemCreationClassName(), SystemName(), TimeOfLastReset()
	{}

	void setProperties(const WmiResult &result, std::size_t index)
	{
		result.extract(index,"Availability",(*this).Availability);
		result.extract(index,"Binary",(*this).Binary);
		result.extract(index,"Capabilities",(*this).Capabilities);
		result.extract(index,"CapabilityDescriptions",(*this).CapabilityDescriptions);
		result.extract(index,"Caption",(*this).Caption);
		result.extract(index,"ConfigManagerErrorCode",(*this).ConfigManagerErrorCode);
		result.extract(index,"ConfigManagerUserConfig",(*this).ConfigManagerUserConfig);
		result.extract(index,"CreationClassName",(*this).CreationClassName);
		result.extract(index,"Description",(*this).Description);
		result.extract(index,"DeviceID",(*this).DeviceID);
		result.extract(index,"ErrorCleared",(*this).ErrorCleared);
		result.extract(index,"ErrorDescription",(*this).ErrorDescription);
		result.extract(index,"InstallDate",(*this).InstallDate);
		result.extract(index,"LastErrorCode",(*this).LastErrorCode);
		result.extract(index,"MaxBaudRate",(*this).MaxBaudRate);
		result.extract(index,"MaximumInputBufferSize",(*this).MaximumInputBufferSize);
		result.extract(index,"MaximumOutputBufferSize",(*this).MaximumOutputBufferSize);
		result.extract(index,"MaxNumberControlled",(*this).MaxNumberControlled);
		result.extract(index,"Name",(*this).Name);
		result.extract(index,"OSAutoDiscovered",(*this).OSAutoDiscovered);
		result.extract(index,"PNPDeviceID",(*this).PNPDeviceID);
		result.extract(index,"PowerManagementCapabilities",(*this).PowerManagementCapabilities);
		result.extract(index,"PowerManagementSupported",(*this).PowerManagementSupported);
		result.extract(index,"ProtocolSupported",(*this).ProtocolSupported);
		result.extract(index,"ProviderType",(*this).ProviderType);
		result.extract(index,"SettableBaudRate",(*this).SettableBaudRate);
		result.extract(index,"SettableDataBits",(*this).SettableDataBits);
		result.extract(index,"SettableFlowControl",(*this).SettableFlowControl);
		result.extract(index,"SettableParity",(*this).SettableParity);
		result.extract(index,"SettableParityCheck",(*this).SettableParityCheck);
		result.extract(index,"SettableRLSD",(*this).SettableRLSD);
		result.extract(index,"SettableStopBits",(*this).SettableStopBits);
		result.extract(index,"Status",(*this).Status);
		result.extract(index,"StatusInfo",(*this).StatusInfo);
		result.extract(index,"Supports16BitMode",(*this).Supports16BitMode);
		result.extract(index,"SupportsDTRDSR",(*this).SupportsDTRDSR);
		result.extract(index,"SupportsElapsedTimeouts",(*this).SupportsElapsedTimeouts);
		result.extract(index,"SupportsIntTimeouts",(*this).SupportsIntTimeouts);
		result.extract(index,"SupportsParityCheck",(*this).SupportsParityCheck);
		result.extract(index,"SupportsRLSD",(*this).SupportsRLSD);
		result.extract(index,"SupportsRTSCTS",(*this).SupportsRTSCTS);
		result.extract(index,"SupportsSpecialCharacters",(*this).SupportsSpecialCharacters);
		result.extract(index,"SupportsXOnXOff",(*this).SupportsXOnXOff);
		result.extract(index,"SupportsXOnXOffSet",(*this).SupportsXOnXOffSet);
		result.extract(index,"SystemCreationClassName",(*this).SystemCreationClassName);
		result.extract(index,"SystemName",(*this).SystemName);
		result.extract(index,"TimeOfLastReset",(*this).TimeOfLastReset);
	}

	static std::string getWmiClassName()
	{
		return "Win32_SerialPort";
	}
	
	int Availability;
	bool Binary;
	std::string Capabilities;
	std::string CapabilityDescriptions;
	std::string Caption;
	int ConfigManagerErrorCode;
	bool ConfigManagerUserConfig;
	std::string CreationClassName;
	std::string Description;
	std::string DeviceID;
	std::string ErrorCleared;
	std::string ErrorDescription;
	std::string InstallDate;
	int LastErrorCode;
	uint64_t MaxBaudRate;
	uint64_t MaximumInputBufferSize;
	uint64_t MaximumOutputBufferSize;
	int MaxNumberControlled;
	std::string Name;
	bool OSAutoDiscovered;
	std::string PNPDeviceID;
	std::string PowerManagementCapabilities;
	bool PowerManagementSupported;
	int ProtocolSupported;
	std::string ProviderType;
	std::string SettableBaudRate;
	std::string SettableDataBits;
	std::string SettableFlowControl;
	std::string SettableParity;
	std::string SettableParityCheck;
	std::string SettableRLSD;
	std::string SettableStopBits;
	std::string Status;
	std::string StatusInfo;
	bool Supports16BitMode;
	bool SupportsDTRDSR;
	bool SupportsElapsedTimeouts;
	bool SupportsIntTimeouts;
	bool SupportsParityCheck;
	bool SupportsRLSD;
	bool SupportsRTSCTS;
	bool SupportsSpecialCharacters;
	bool SupportsXOnXOff;
	bool SupportsXOnXOffSet;
	std::string SystemCreationClassName;
	std::string SystemName;
	std::string TimeOfLastReset;

}; //end Win32_SerialPort

struct SoftwareLicensingService
{
	SoftwareLicensingService():
	ClientMachineID(),
	DiscoveredKeyManagementServiceMachineIpAddress(),
	DiscoveredKeyManagementServiceMachineName(),
	DiscoveredKeyManagementServiceMachinePort(),
	IsKeyManagementServiceMachine(),
	KeyManagementServiceCurrentCount(),
	KeyManagementServiceDnsPublishing(),
	KeyManagementServiceFailedRequests(),
	KeyManagementServiceHostCaching(),
	KeyManagementServiceLicensedRequests(),
	KeyManagementServiceListeningPort(),
	KeyManagementServiceLookupDomain(),
	KeyManagementServiceLowPriority(),
	KeyManagementServiceMachine(),
	KeyManagementServiceNonGenuineGraceRequests(),
	KeyManagementServiceNotificationRequests(),
	KeyManagementServiceOOBGraceRequests(),
	KeyManagementServiceOOTGraceRequests(),
	KeyManagementServicePort(),
	KeyManagementServiceProductKeyID(),
	KeyManagementServiceTotalRequests(),
	KeyManagementServiceUnlicensedRequests(),
	OA2xBiosMarkerMinorVersion(),
	OA2xBiosMarkerStatus(),
	OA3xOriginalProductKey(),
	OA3xOriginalProductKeyDescription(),
	OA3xOriginalProductKeyPkPn(),
	PolicyCacheRefreshRequired(),
	RemainingWindowsReArmCount(),
	RequiredClientCount(),
	TokenActivationAdditionalInfo(),
	TokenActivationCertificateThumbprint(),
	TokenActivationGrantNumber(),
	TokenActivationILID(),
	TokenActivationILVID(),
	Version(),
	VLActivationInterval(),
	VLRenewalInterval()
	{}

	void setProperties(const WmiResult &result, std::size_t index)
	{
		result.extract(index, "ClientMachineID", (*this).ClientMachineID);
		result.extract(index, "DiscoveredKeyManagementServiceMachineIpAddress", (*this).DiscoveredKeyManagementServiceMachineIpAddress);
		result.extract(index, "DiscoveredKeyManagementServiceMachineName", (*this).DiscoveredKeyManagementServiceMachineName);
		result.extract(index, "DiscoveredKeyManagementServiceMachinePort", (*this).DiscoveredKeyManagementServiceMachinePort);
		result.extract(index, "IsKeyManagementServiceMachine", (*this).IsKeyManagementServiceMachine);
		result.extract(index, "KeyManagementServiceCurrentCount", (*this).KeyManagementServiceCurrentCount);
		result.extract(index, "KeyManagementServiceDnsPublishing", (*this).KeyManagementServiceDnsPublishing);
		result.extract(index, "KeyManagementServiceFailedRequests", (*this).KeyManagementServiceFailedRequests);
		result.extract(index, "KeyManagementServiceHostCaching", (*this).KeyManagementServiceHostCaching);
		result.extract(index, "KeyManagementServiceLicensedRequests", (*this).KeyManagementServiceLicensedRequests);
		result.extract(index, "KeyManagementServiceListeningPort", (*this).KeyManagementServiceListeningPort);
		result.extract(index, "KeyManagementServiceLookupDomain", (*this).KeyManagementServiceLookupDomain);
		result.extract(index, "KeyManagementServiceLowPriority", (*this).KeyManagementServiceLowPriority);
		result.extract(index, "KeyManagementServiceMachine", (*this).KeyManagementServiceMachine);
		result.extract(index, "KeyManagementServiceNonGenuineGraceRequests", (*this).KeyManagementServiceNonGenuineGraceRequests);
		result.extract(index, "KeyManagementServiceNotificationRequests", (*this).KeyManagementServiceNotificationRequests);
		result.extract(index, "KeyManagementServiceOOBGraceRequests", (*this).KeyManagementServiceOOBGraceRequests);
		result.extract(index, "KeyManagementServiceOOTGraceRequests", (*this).KeyManagementServiceOOTGraceRequests);
		result.extract(index, "KeyManagementServicePort", (*this).KeyManagementServicePort);
		result.extract(index, "KeyManagementServiceProductKeyID", (*this).KeyManagementServiceProductKeyID);
		result.extract(index, "KeyManagementServiceTotalRequests", (*this).KeyManagementServiceTotalRequests);
		result.extract(index, "KeyManagementServiceUnlicensedRequests", (*this).KeyManagementServiceUnlicensedRequests);
		result.extract(index, "OA2xBiosMarkerMinorVersion", (*this).OA2xBiosMarkerMinorVersion);
		result.extract(index, "OA2xBiosMarkerStatus", (*this).OA2xBiosMarkerStatus);
		result.extract(index, "OA3xOriginalProductKey", (*this).OA3xOriginalProductKey);
		result.extract(index, "OA3xOriginalProductKeyDescription", (*this).OA3xOriginalProductKeyDescription);
		result.extract(index, "OA3xOriginalProductKeyPkPn", (*this).OA3xOriginalProductKeyPkPn);
		result.extract(index, "PolicyCacheRefreshRequired", (*this).PolicyCacheRefreshRequired);
		result.extract(index, "RemainingWindowsReArmCount", (*this).RemainingWindowsReArmCount);
		result.extract(index, "RequiredClientCount", (*this).RequiredClientCount);
		result.extract(index, "TokenActivationAdditionalInfo", (*this).TokenActivationAdditionalInfo);
		result.extract(index, "TokenActivationCertificateThumbprint", (*this).TokenActivationCertificateThumbprint);
		result.extract(index, "TokenActivationGrantNumber", (*this).TokenActivationGrantNumber);
		result.extract(index, "TokenActivationILID", (*this).TokenActivationILID);
		result.extract(index, "TokenActivationILVID", (*this).TokenActivationILVID);
		result.extract(index, "Version", (*this).Version);
		result.extract(index, "VLActivationInterval", (*this).VLActivationInterval);
		result.extract(index, "VLRenewalInterval", (*this).VLRenewalInterval);
	}
	static std::string getWmiClassName()
	{
		return "SoftwareLicensingService";
	}
	std::string ClientMachineID;
	std::string DiscoveredKeyManagementServiceMachineIpAddress;
	std::string DiscoveredKeyManagementServiceMachineName;
	int DiscoveredKeyManagementServiceMachinePort;
	int IsKeyManagementServiceMachine ;
	int KeyManagementServiceCurrentCount ;
	bool KeyManagementServiceDnsPublishing ;
	int KeyManagementServiceFailedRequests ;
	bool KeyManagementServiceHostCaching ;
	int KeyManagementServiceLicensedRequests ;
	int KeyManagementServiceListeningPort ;
	std::string KeyManagementServiceLookupDomain;
	bool KeyManagementServiceLowPriority ;
	std::string KeyManagementServiceMachine;
	int KeyManagementServiceNonGenuineGraceRequests ;
	int KeyManagementServiceNotificationRequests ;
	int KeyManagementServiceOOBGraceRequests ;
	int KeyManagementServiceOOTGraceRequests ;
	int KeyManagementServicePort ;
	std::string KeyManagementServiceProductKeyID;
	int KeyManagementServiceTotalRequests ;
	int KeyManagementServiceUnlicensedRequests ;
	int OA2xBiosMarkerMinorVersion ;
	int OA2xBiosMarkerStatus ;
	std::string OA3xOriginalProductKey;
	std::string OA3xOriginalProductKeyDescription;
	std::string OA3xOriginalProductKeyPkPn;
	int PolicyCacheRefreshRequired ;
	int RemainingWindowsReArmCount ;
	int RequiredClientCount ;
	std::string TokenActivationAdditionalInfo;
	int TokenActivationCertificateThumbprint;
	int TokenActivationGrantNumber ;
	std::string TokenActivationILID;
	int TokenActivationILVID ;
	std::string Version;
	int VLActivationInterval ;
	int VLRenewalInterval ;
};

struct Win32_LogicalDisk
{
	Win32_LogicalDisk() :
		Access(), Availability(), BlockSize(), Caption(), Compressed(), ConfigManagerErrorCode(),
		ConfigManagerUserConfig(), CreationClassName(), Description(), DeviceID(), DriveType(),
		ErrorCleared(), ErrorDescription(), ErrorMethodology(), FileSystem(), FreeSpace(), InstallDate(),
		LastErrorCode(), MaximumComponentLength(), MediaType(), Name(), NumberOfBlocks(), PNPDeviceID(),
		PowerManagementCapabilities(), PowerManagementSupported(), ProviderName(), Purpose(), QuotasDisabled(),
		QuotasIncomplete(), QuotasRebuilding(), Size(), Status(), StatusInfo(), SupportsDiskQuotas(),
		SupportsFileBasedCompression(), SystemCreationClassName(), SystemName(), VolumeDirty(),
		VolumeName(), VolumeSerialNumber()
	{}

	void setProperties(const WmiResult& result, std::size_t index)
	{
		result.extract(index, "Access", (*this).Access);
		result.extract(index, "Availability", (*this).Availability);
		result.extract(index, "BlockSize", (*this).BlockSize);
		result.extract(index, "Caption", (*this).Caption);
		result.extract(index, "Compressed", (*this).Compressed);
		result.extract(index, "ConfigManagerErrorCode", (*this).ConfigManagerErrorCode);
		result.extract(index, "ConfigManagerUserConfig", (*this).ConfigManagerUserConfig);
		result.extract(index, "CreationClassName", (*this).CreationClassName);
		result.extract(index, "Description", (*this).Description);
		result.extract(index, "DeviceID", (*this).DeviceID);
		result.extract(index, "DriveType", (*this).DriveType);
		result.extract(index, "ErrorCleared", (*this).ErrorCleared);
		result.extract(index, "ErrorDescription", (*this).ErrorDescription);
		result.extract(index, "ErrorMethodology", (*this).ErrorMethodology);
		result.extract(index, "FileSystem", (*this).FileSystem);
		result.extract(index, "FreeSpace", (*this).FreeSpace);
		result.extract(index, "InstallDate", (*this).InstallDate);
		result.extract(index, "LastErrorCode", (*this).LastErrorCode);
		result.extract(index, "MaximumComponentLength", (*this).MaximumComponentLength);
		result.extract(index, "MediaType", (*this).MediaType);
		result.extract(index, "Name", (*this).Name);
		result.extract(index, "NumberOfBlocks", (*this).NumberOfBlocks);
		result.extract(index, "PNPDeviceID", (*this).PNPDeviceID);
		result.extract(index, "PowerManagementCapabilities", (*this).PowerManagementCapabilities);
		result.extract(index, "PowerManagementSupported", (*this).PowerManagementSupported);
		result.extract(index, "ProviderName", (*this).ProviderName);
		result.extract(index, "Purpose", (*this).Purpose);
		result.extract(index, "QuotasDisabled", (*this).QuotasDisabled);
		result.extract(index, "QuotasIncomplete", (*this).QuotasIncomplete);
		result.extract(index, "QuotasRebuilding", (*this).QuotasRebuilding);
		result.extract(index, "Size", (*this).Size);
		result.extract(index, "StatusInfo", (*this).StatusInfo);
		result.extract(index, "SupportsDiskQuotas", (*this).SupportsDiskQuotas);
		result.extract(index, "SupportsFileBasedCompression", (*this).SupportsFileBasedCompression);
		result.extract(index, "SystemCreationClassName", (*this).SystemCreationClassName);
		result.extract(index, "SystemName", (*this).SystemName);
		result.extract(index, "VolumeDirty", (*this).VolumeDirty);
		result.extract(index, "VolumeName", (*this).VolumeName);
		result.extract(index, "VolumeSerialNumber", (*this).VolumeSerialNumber);
	}

	static std::string getWmiClassName()
	{
		return "Win32_LogicalDisk";
	}

	int Access;
	int Availability;
	std::string BlockSize;
	std::string Caption;
	bool Compressed;
	int ConfigManagerErrorCode;
	bool ConfigManagerUserConfig;
	std::string CreationClassName;
	std::string Description;
	std::string DeviceID;
	int DriveType;
	bool ErrorCleared;
	std::string ErrorDescription;
	std::string ErrorMethodology;
	std::string FileSystem;
	std::string FreeSpace;
	std::string InstallDate;
	int LastErrorCode;
	int MaximumComponentLength;
	int MediaType;
	std::string Name;
	std::string NumberOfBlocks;
	std::string PNPDeviceID;
	std::string PowerManagementCapabilities;
	std::string PowerManagementSupported;
	std::string ProviderName;
	std::string Purpose;
	bool QuotasDisabled;
	bool QuotasIncomplete;
	bool QuotasRebuilding;
	std::string Size;
	std::string Status;
	std::string StatusInfo;
	bool SupportsDiskQuotas;
	bool SupportsFileBasedCompression;
	std::string SystemCreationClassName;
	std::string SystemName;
	bool VolumeDirty;
	std::string VolumeName;
	std::string VolumeSerialNumber;
}; //end Win32_LogicalDisk

struct Win32_OperatingSystem
{
	Win32_OperatingSystem():
	BootDevice(),
	BuildNumber(),
	BuildType(),
	Caption(),
	CodeSet(),
	CountryCode(),
	CreationClassName(),
	CSCreationClassName(),
	CSName(),
	CurrentTimeZone(),
	DataExecutionPrevention_32BitApplications(),
	DataExecutionPrevention_Available(),
	DataExecutionPrevention_Drivers(),
	DataExecutionPrevention_SupportPolicy(),
	Debug(),
	Description(),
	Distributed(),
	EncryptionLevel(),
	ForegroundApplicationBoost(),
	FreePhysicalMemory(),
	FreeSpaceInPagingFiles(),
	FreeVirtualMemory(),
	InstallDate(),
	LastBootUpTime(),
	LocalDateTime(),
	Locale(),
	Manufacturer(),
	MaxNumberOfProcesses(),
	MaxProcessMemorySize(),
	MUILanguages(),
	Name(),
	NumberOfProcesses(),
	NumberOfUsers(),
	OperatingSystemSKU(),
	Organization(),
	OSArchitecture(),
	OSLanguage(),
	OSProductSuite(),
	OSType(),
	PortableOperatingSystem(),
	Primary(),
	ProductType(),
	RegisteredUser(),
	SerialNumber(),
	ServicePackMajorVersion(),
	ServicePackMinorVersion(),
	SizeStoredInPagingFiles(),
	Status(),
	SuiteMask(),
	SystemDevice(),
	SystemDirectory(),
	SystemDrive(),
	TotalVirtualMemorySize(),
	TotalVisibleMemorySize(),
	Version(),
	WindowsDirectory()
	{}

	void setProperties(const WmiResult &result, std::size_t index)
	{
		result.extract(index, "BootDevice", (*this).BootDevice);
		result.extract(index, "BuildNumber", (*this).BuildNumber);
		result.extract(index, "BuildType", (*this).BuildType);
		result.extract(index, "Caption", (*this).Caption);
		result.extract(index, "CodeSet", (*this).CodeSet);
		result.extract(index, "CountryCode", (*this).CountryCode);
		result.extract(index, "CreationClassName", (*this).CreationClassName);
		result.extract(index, "CSCreationClassName", (*this).CSCreationClassName);
		result.extract(index, "CSName", (*this).CSName);
		result.extract(index, "CurrentTimeZone", (*this).CurrentTimeZone);
		result.extract(index, "DataExecutionPrevention_32BitApplications", (*this).DataExecutionPrevention_32BitApplications);
		result.extract(index, "DataExecutionPrevention_Available", (*this).DataExecutionPrevention_Available);
		result.extract(index, "DataExecutionPrevention_Drivers", (*this).DataExecutionPrevention_Drivers);
		result.extract(index, "DataExecutionPrevention_SupportPolicy", (*this).DataExecutionPrevention_SupportPolicy);
		result.extract(index, "Debug", (*this).Debug);
		result.extract(index, "Description", (*this).Description);
		result.extract(index, "Distributed", (*this).Distributed);
		result.extract(index, "EncryptionLevel", (*this).EncryptionLevel);
		result.extract(index, "ForegroundApplicationBoost", (*this).ForegroundApplicationBoost);
		result.extract(index, "FreePhysicalMemory", (*this).FreePhysicalMemory);
		result.extract(index, "FreeSpaceInPagingFiles", (*this).FreeSpaceInPagingFiles);
		result.extract(index, "FreeVirtualMemory", (*this).FreeVirtualMemory);
		result.extract(index, "InstallDate", (*this).InstallDate);
		result.extract(index, "LastBootUpTime", (*this).LastBootUpTime);
		result.extract(index, "LocalDateTime", (*this).LocalDateTime);
		result.extract(index, "Locale", (*this).Locale);
		result.extract(index, "Manufacturer", (*this).Manufacturer);
		result.extract(index, "MaxNumberOfProcesses", (*this).MaxNumberOfProcesses);
		result.extract(index, "MaxProcessMemorySize", (*this).MaxProcessMemorySize);
		result.extract(index, "MUILanguages", (*this).MUILanguages);
		result.extract(index, "Name", (*this).Name);
		result.extract(index, "NumberOfProcesses", (*this).NumberOfProcesses);
		result.extract(index, "NumberOfUsers", (*this).NumberOfUsers);
		result.extract(index, "OperatingSystemSKU", (*this).OperatingSystemSKU);
		result.extract(index, "Organization", (*this).Organization);
		result.extract(index, "OSArchitecture", (*this).OSArchitecture);
		result.extract(index, "OSLanguage", (*this).OSLanguage);
		result.extract(index, "OSProductSuite", (*this).OSProductSuite);
		result.extract(index, "OSType", (*this).OSType);
		result.extract(index, "PortableOperatingSystem", (*this).PortableOperatingSystem);
		result.extract(index, "Primary", (*this).Primary);
		result.extract(index, "ProductType", (*this).ProductType);
		result.extract(index, "RegisteredUser", (*this).RegisteredUser);
		result.extract(index, "SerialNumber", (*this).SerialNumber);
		result.extract(index, "ServicePackMajorVersion", (*this).ServicePackMajorVersion);
		result.extract(index, "ServicePackMinorVersion", (*this).ServicePackMinorVersion);
		result.extract(index, "SizeStoredInPagingFiles", (*this).SizeStoredInPagingFiles);
		result.extract(index, "Status", (*this).Status);
		result.extract(index, "SuiteMask", (*this).SuiteMask);
		result.extract(index, "SystemDevice", (*this).SystemDevice);
		result.extract(index, "SystemDirectory", (*this).SystemDirectory);
		result.extract(index, "SystemDrive", (*this).SystemDrive);
		result.extract(index, "TotalVirtualMemorySize", (*this).TotalVirtualMemorySize);
		result.extract(index, "TotalVisibleMemorySize", (*this).TotalVisibleMemorySize);
		result.extract(index, "Version", (*this).Version);
		result.extract(index, "WindowsDirectory", (*this).WindowsDirectory);
		 
	}
	static std::string getWmiClassName()
	{
		return "Win32_OperatingSystem";
	}
	std::string BootDevice ;
	std::string BuildNumber ;
	std::string BuildType ;
	std::string Caption ;
	std::string CodeSet ;
	std::string CountryCode ;
	std::string CreationClassName ;
	std::string CSCreationClassName ;
	std::string CSName ;
	int CurrentTimeZone ;
	bool DataExecutionPrevention_32BitApplications ;
	bool DataExecutionPrevention_Available ;
	bool DataExecutionPrevention_Drivers ;
	int DataExecutionPrevention_SupportPolicy ;
	bool Debug ;
	std::string Description ;
	bool Distributed ;
	int EncryptionLevel ;
	int ForegroundApplicationBoost ;
	uint64_t    FreePhysicalMemory ;
	uint64_t    FreeSpaceInPagingFiles ;
	uint64_t    FreeVirtualMemory ;
	/////////////////////////////////////////////////////
	std::string InstallDate ;
	std::string LastBootUpTime ;///THIS MAYBE INCORRECT
	std::string LocalDateTime ;
	/////////////////////////////////////////////////////////
	std::string Locale ;
	std::string Manufacturer ;
	uint64_t    MaxNumberOfProcesses ;
	uint64_t    MaxProcessMemorySize ;
	std::string MUILanguages ;
	std::string Name ;
	int NumberOfProcesses ;
	int NumberOfUsers ;
	int OperatingSystemSKU ;
	std::string Organization ;
	std::string OSArchitecture ;
	int OSLanguage ;
	int OSProductSuite ;
	int OSType ;
	bool PortableOperatingSystem ;
	bool Primary ;
	int ProductType ;
	std::string RegisteredUser ;
	std::string SerialNumber ;
	int ServicePackMajorVersion ;
	int ServicePackMinorVersion ;
	uint64_t    SizeStoredInPagingFiles ;
	std::string Status ;
	int SuiteMask ;
	std::string SystemDevice ;
	std::string SystemDirectory ;
	std::string SystemDrive ;
	uint64_t    TotalVirtualMemorySize ;
	uint64_t    TotalVisibleMemorySize ;
	std::string Version ;
	std::string WindowsDirectory ;
};

struct Win32_VideoController
{
	Win32_VideoController() :
		AcceleratorCapabilities(),AdapterCompatibility(),AdapterDACType(),AdapterRAM(),Availability(),
        CapabilityDescriptions(),Caption(),ColorTableEntries(),ConfigManagerErrorCode(),ConfigManagerUserConfig(),
        CreationClassName(),CurrentBitsPerPixel(),CurrentHorizontalResolution(),CurrentNumberOfColors(),
        CurrentNumberOfColumns(),CurrentNumberOfRows(),CurrentRefreshRate(),CurrentScanMode(),CurrentVerticalResolution(),
        Description(),DeviceID(),DeviceSpecificPens(),DitherType(),DriverDate(),DriverVersion(),ErrorCleared(),
        ErrorDescription(),ICMIntent(),ICMMethod(),InfFilename(),InfSection(),InstallDate(),InstalledDisplayDrivers(),
        LastErrorCode(),MaxMemorySupported(),MaxNumberControlled(),MaxRefreshRate(),MinRefreshRate(),Monochrome(),Name(),
        NumberOfColorPlanes(),NumberOfVideoPages(),PNPDeviceID(),PowerManagementCapabilities(),PowerManagementSupported(),
        ProtocolSupported(),ReservedSystemPaletteEntries(),SpecificationVersion(),Status(),StatusInfo(),
        SystemCreationClassName(),SystemName(),SystemPaletteEntries(),TimeOfLastReset(),VideoArchitecture(),
        VideoMemoryType(),VideoMode(),VideoModeDescription(),VideoProcessor()
	{}

	void setProperties(const WmiResult& result, std::size_t index)
	{
		result.extract(index, "AcceleratorCapabilities", (*this).AcceleratorCapabilities);
		result.extract(index, "AdapterCompatibility", (*this).AdapterCompatibility);
		result.extract(index, "AdapterDACType", (*this).AdapterDACType);
		result.extract(index, "AdapterRAM", (*this).AdapterRAM);
		result.extract(index, "Availability", (*this).Availability);
		result.extract(index, "CapabilityDescriptions", (*this).CapabilityDescriptions);
		result.extract(index, "Caption", (*this).Caption);
		result.extract(index, "ColorTableEntries", (*this).ColorTableEntries);
		result.extract(index, "ConfigManagerErrorCode", (*this).ConfigManagerErrorCode);
		result.extract(index, "ConfigManagerUserConfig", (*this).ConfigManagerUserConfig);
		result.extract(index, "CreationClassName", (*this).CreationClassName);
		result.extract(index, "CurrentBitsPerPixel", (*this).CurrentBitsPerPixel);
		result.extract(index, "CurrentHorizontalResolution", (*this).CurrentHorizontalResolution);
		result.extract(index, "CurrentNumberOfColors", (*this).CurrentNumberOfColors);
		result.extract(index, "CurrentNumberOfColumns", (*this).CurrentNumberOfColumns);
		result.extract(index, "CurrentNumberOfRows", (*this).CurrentNumberOfRows);
		result.extract(index, "CurrentRefreshRate", (*this).CurrentRefreshRate);
		result.extract(index, "CurrentScanMode", (*this).CurrentScanMode);
		result.extract(index, "CurrentVerticalResolution", (*this).CurrentVerticalResolution);
		result.extract(index, "Description", (*this).Description);
		result.extract(index, "DeviceID", (*this).DeviceID);
		result.extract(index, "DeviceSpecificPens", (*this).DeviceSpecificPens);
		result.extract(index, "DitherType", (*this).DitherType);
		result.extract(index, "DriverDate", (*this).DriverDate);
		result.extract(index, "DriverVersion", (*this).DriverVersion);
		result.extract(index, "ErrorCleared", (*this).ErrorCleared);
		result.extract(index, "ErrorDescription", (*this).ErrorDescription);
		result.extract(index, "ICMIntent", (*this).ICMIntent);
		result.extract(index, "ICMMethod", (*this).ICMMethod);
		result.extract(index, "InfFilename", (*this).InfFilename);
		result.extract(index, "InfSection", (*this).InfSection);
		result.extract(index, "InstallDate", (*this).InstallDate);
		result.extract(index, "InstalledDisplayDrivers", (*this).InstalledDisplayDrivers);
		result.extract(index, "LastErrorCode", (*this).LastErrorCode);
		result.extract(index, "MaxMemorySupported", (*this).MaxMemorySupported);
		result.extract(index, "MaxNumberControlled", (*this).MaxNumberControlled);
		result.extract(index, "MaxRefreshRate", (*this).MaxRefreshRate);
		result.extract(index, "MinRefreshRate", (*this).MinRefreshRate);
		result.extract(index, "Monochrome", (*this).Monochrome);
		result.extract(index, "Name", (*this).Name);
		result.extract(index, "NumberOfColorPlanes", (*this).NumberOfColorPlanes);
		result.extract(index, "NumberOfVideoPages", (*this).NumberOfVideoPages);
		result.extract(index, "PNPDeviceID", (*this).PNPDeviceID);
		result.extract(index, "PowerManagementCapabilities", (*this).PowerManagementCapabilities);
		result.extract(index, "PowerManagementSupported", (*this).PowerManagementSupported);
		result.extract(index, "ProtocolSupported", (*this).ProtocolSupported);
		result.extract(index, "ReservedSystemPaletteEntries", (*this).ReservedSystemPaletteEntries);
		result.extract(index, "SpecificationVersion", (*this).SpecificationVersion);
		result.extract(index, "Status", (*this).Status);
		result.extract(index, "StatusInfo", (*this).StatusInfo);
		result.extract(index, "SystemCreationClassName", (*this).SystemCreationClassName);
		result.extract(index, "SystemName", (*this).SystemName);
		result.extract(index, "SystemPaletteEntries", (*this).SystemPaletteEntries);
		result.extract(index, "TimeOfLastReset", (*this).TimeOfLastReset);
		result.extract(index, "VideoArchitecture", (*this).VideoArchitecture);
		result.extract(index, "VideoMemoryType", (*this).VideoMemoryType);
		result.extract(index, "VideoMode", (*this).VideoMode);
		result.extract(index, "VideoModeDescription", (*this).VideoModeDescription);
		result.extract(index, "VideoProcessor", (*this).VideoProcessor);
	}

	static std::string getWmiClassName()
	{
		return "Win32_VideoController";
	}

	std::string   AcceleratorCapabilities;
	std::string   AdapterCompatibility;
	std::string   AdapterDACType;
	std::uint32_t AdapterRAM;
	std::uint16_t Availability;
	std::string   CapabilityDescriptions;
	std::string   Caption;
	std::uint32_t ColorTableEntries;
	std::uint32_t ConfigManagerErrorCode;
	bool          ConfigManagerUserConfig;
	std::string   CreationClassName;
	std::uint32_t CurrentBitsPerPixel;
	std::uint32_t CurrentHorizontalResolution;
	std::uint64_t CurrentNumberOfColors;
	std::uint32_t CurrentNumberOfColumns;
	std::uint32_t CurrentNumberOfRows;
	std::uint32_t CurrentRefreshRate;
	std::uint16_t CurrentScanMode;
	std::uint32_t CurrentVerticalResolution;
	std::string   Description;
	std::string   DeviceID;
	std::uint32_t DeviceSpecificPens;
	std::uint32_t DitherType;
	std::string   DriverDate;
	std::string   DriverVersion;
	bool          ErrorCleared;
	std::string   ErrorDescription;
	std::uint32_t ICMIntent;
	std::uint32_t ICMMethod;
	std::string   InfFilename;
	std::string   InfSection;
	std::string   InstallDate;
	std::string   InstalledDisplayDrivers;
	std::uint32_t LastErrorCode;
	std::uint32_t MaxMemorySupported;
	std::uint32_t MaxNumberControlled;
	std::uint32_t MaxRefreshRate;
	std::uint32_t MinRefreshRate;
	bool          Monochrome;
	std::string   Name;
	std::uint16_t NumberOfColorPlanes;
	std::uint32_t NumberOfVideoPages;
	std::string   PNPDeviceID;
	std::string   PowerManagementCapabilities;
	bool          PowerManagementSupported;
	std::uint16_t ProtocolSupported;
	std::uint32_t ReservedSystemPaletteEntries;
	std::uint32_t SpecificationVersion;
	std::string   Status;
	std::uint16_t StatusInfo;
	std::string   SystemCreationClassName;
	std::string   SystemName;
	std::uint32_t SystemPaletteEntries;
	std::string   TimeOfLastReset;
	std::uint16_t VideoArchitecture;
	std::uint16_t VideoMemoryType;
	std::uint16_t VideoMode;
	std::string   VideoModeDescription;
	std::string   VideoProcessor;
};

struct Win32_BaseBoard
{
	Win32_BaseBoard() :
		Caption(), ConfigOptions(), CreationClassName(), Depth(), Description(), Height(), HostingBoard(), HotSwappable(), InstallDate(),
		Manufacturer(), Model(), Name(), OtherIdentifyingInfo(), PartNumber(), PoweredOn(), Product(), Removable(), Replaceable(), RequirementsDescription(),
		RequiresDaughterBoard(), SerialNumber(), SKU(), SlotLayout(), SpecialRequirements(), Status(), Tag(), Version(), Weight(), Width()
	{}

	void setProperties(const WmiResult& result, std::size_t index)
	{
		//vscode was a great help with search(.+?), 
		//and replace result.extract(index, "$1", (*this).$1);
		result.extract(index, "Caption", (*this).Caption);
		result.extract(index, "ConfigOptions", (*this).ConfigOptions);
		result.extract(index, "CreationClassName", (*this).CreationClassName);
		result.extract(index, "Depth", (*this).Depth);
		result.extract(index, "Description", (*this).Description);
		result.extract(index, "Height", (*this).Height);
		result.extract(index, "HostingBoard", (*this).HostingBoard);
		result.extract(index, "HotSwappable", (*this).HotSwappable);
		result.extract(index, "InstallDate", (*this).InstallDate);
		result.extract(index, "Manufacturer", (*this).Manufacturer);
		result.extract(index, "Model", (*this).Model);
		result.extract(index, "Name", (*this).Name);
		result.extract(index, "OtherIdentifyingInfo", (*this).OtherIdentifyingInfo);
		result.extract(index, "PoweredOn", (*this).PoweredOn);
		result.extract(index, "Product", (*this).Product);
		result.extract(index, "Removable", (*this).Removable);
		result.extract(index, "Replaceable", (*this).Replaceable);
		result.extract(index, "RequirementsDescription", (*this).RequirementsDescription);
		result.extract(index, "RequiresDaughterBoard", (*this).RequiresDaughterBoard);
		result.extract(index, "SerialNumber", (*this).SerialNumber);
		result.extract(index, "SKU", (*this).SKU);
		result.extract(index, "SlotLayout", (*this).SlotLayout);
		result.extract(index, "SpecialRequirements", (*this).SpecialRequirements);
		result.extract(index, "Status", (*this).Status);
		result.extract(index, "Tag", (*this).Tag);
		result.extract(index, "Version", (*this).Version);
		result.extract(index, "Weight", (*this).Weight);
		result.extract(index, "Width", (*this).Width);
	}

	static std::string getWmiClassName()
	{
		return "Win32_BaseBoard";
	}

	std::string Caption;
	std::string ConfigOptions;
	std::string CreationClassName;
	int Depth;
	std::string Description;
	int Height;
	bool HostingBoard;
	bool HotSwappable;
	std::string InstallDate;
	std::string Manufacturer;
	std::string Model;
	std::string Name;
	std::string OtherIdentifyingInfo;
	std::string PartNumber;
	bool PoweredOn;
	std::string Product;
	bool Removable;
	bool Replaceable;
	std::string RequirementsDescription;
	std::string RequiresDaughterBoard;
	std::string SerialNumber;
	std::string SKU;
	std::string SlotLayout;
	std::string SpecialRequirements;
	std::string Status;
	std::string Tag;
	std::string Version;
	int Weight;
	int Width;
}; //end class Win32_BaseBoard

struct UWF_Filter
{
	UWF_Filter() :
		Id(), CurrentEnabled(), NextEnabled(), HORMEnabled(), ShutdownPending()
	{}

	void setProperties(const WmiResult& result, std::size_t index)
	{
		//vscode was a great help with search(.+?), 
		//and replace result.extract(index, "$1", (*this).$1);
		result.extract(index, "Id", (*this).Id);
		result.extract(index, "CurrentEnabled", (*this).CurrentEnabled);
		result.extract(index, "NextEnabled", (*this).NextEnabled);
		result.extract(index, "HORMEnabled", (*this).HORMEnabled);
		result.extract(index, "ShutdownPending", (*this).ShutdownPending);
	}

	static std::string getWmiClassName()
	{
		return "UWF_Filter";
	}
	static std::string getWmiPath()
	{
		return "standardcimv2\\embedded";
	}

	std::string Id;
	bool CurrentEnabled;
	bool NextEnabled;
	bool HORMEnabled;
	bool ShutdownPending;
}; //end class UWF_Filter

struct AntiVirusProduct
{
	AntiVirusProduct() :
		DisplayName(), InstanceGuid(), PathToSignedProductExe(), PathToSignedReportingExe(), ProductState(), Timestamp()
	{}

	void setProperties(const WmiResult& result, std::size_t index)
	{
		//vscode was a great help with search(.+?), 
		//and replace result.extract(index, "$1", (*this).$1);
		result.extract(index, "DisplayName", (*this).DisplayName);
		result.extract(index, "InstanceGuid", (*this).InstanceGuid);
		result.extract(index, "PathToSignedProductExe", (*this).PathToSignedProductExe);
		result.extract(index, "PathToSignedReportingExe", (*this).PathToSignedReportingExe);
		result.extract(index, "ProductState", (*this).ProductState);
		result.extract(index, "Timestamp", (*this).Timestamp);
	}

	static std::string getWmiClassName()
	{
		return "AntiVirusProduct";
	}
	static std::string getWmiPath()
	{
		return "securitycenter2";
	}

	std::string DisplayName;
	std::string InstanceGuid;
	std::string PathToSignedProductExe;
	std::string PathToSignedReportingExe;
	std::uint32_t ProductState;
	std::string Timestamp;
}; //end class AntiVirusProduct

} //end namespace wmi

#endif //WMICLASSES_HPP