File Coverage

blib/lib/DMTF/CIM.pm

Criterion	Covered	Total	%
statement	15	265	5.6
branch	0	122	0.0
condition	0	41	0.0
subroutine	5	38	13.1
pod	18	33	54.5
total	38	499	7.6

package DMTF::CIM;

use warnings;
use strict;

use version;
our $VERSION = qv('0.04');

use DMTF::CIM::Instance;
use Carp;

sub new
{
	my $self={};
	$self->{CLASS} = shift;
	$self->{MODEL} = undef;
	$self->{UFcT} = {
		authorizedpriv		=> {class => 'CIM_AuthorizedPrivilege'},
		configcapacity		=> {class => 'CIM_ConfigurationCapacity'},
		location			=> {class => 'CIM_Location'},
		record				=> {class => 'CIM_LogRecord'},
		namespace			=> {class => 'CIM_Namespace'},
		plocation			=> {class => 'CIM_PhysicalLocation'},
		product				=> {class => 'CIM_Product'},
		profile				=> {class => 'CIM_RegisteredProfile'},
		subprofile			=> {class => 'CIM_RegisteredSubProfile'},
		mapcap				=> {class => 'CIM_MAPCapabilities'},
		sharingcap			=> {class => 'CIM_DeviceSharingCapabilities'},
		pwrmgtcap			=> {class => 'CIM_PowerManagementCapabilities'},
		swinstallsvccap		=> {class => 'CIM_SoftwareInstallationServiceCapabilities'},
		storagecap			=> {class => 'CIM_StorageCapabilities'},
		storagecfgcap		=> {class => 'CIM_StorageConfigurationCapabilities'},
		dhcpcap				=> {class => 'CIM_DHCPCapabilities'},
		bootcfgsetting		=> {class => 'CIM_BootConfigSetting'},
		bootsrcsetting		=> {class => 'CIM_BootSourceSetting'},
		bootsetting			=> {class => 'CIM_BootSettingData'},
		displaysetting		=> {class => 'CIM_DisplaySetting'},
		mapsetting			=> {class => 'CIM_MAPSetting'},
		nicsetting			=> {class => 'CIM_NicSetting'},
		storagesetting		=> {class => 'CIM_StorageSetting'},
		ipsettings			=> {class => 'CIM_IPAssignmentSettingData'},
		staticipsettings	=> {class => 'CIM_StaticIPAssignmentSettingData'},
		dhcpsettings		=> {class => 'CIM_DHCPSettingData'},
		dnssettings			=> {class => 'CIM_DNSSettingData'},
		dnsgeneralsettings	=> {class => 'CIM_DNSGeneralSettingData'},
		group				=> {class => 'CIM_Group'},
		redundancyset		=> {class => 'CIM_RedundancySet'},
		swrepo				=> {class => 'CIM_SoftwareRepository'},
		concretecollection	=> {class => 'CIM_ConcreteCollection'},
		hdwr				=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Hardware"'},
		capabilities		=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Capabilities"'},
		capacities			=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Capacities"'},
		consoles			=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Consoles"'},
		logs				=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Logs"'},
		profiles			=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Profiles"'},
		privileges			=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Privileges"'},
		products			=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Products"'},
		settings			=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Settings"'},
		sensors				=> {class => 'CIM_ConcreteCollection', where=>'ElementName="Sensors"'},
		swid				=> {class => 'CIM_SoftwareIdentity'},
		storagepool			=> {class => 'CIM_StoragePool'},
		account				=> {class => 'CIM_Account'},
		job					=> {class => 'CIM_ConcreteJob'},
		jobq				=> {class => 'CIM_JobQueue'},
		log					=> {class => 'CIM_RecordLog'},
		os					=> {class => 'CIM_OperatingSystem'},
		admin				=> {class => 'CIM_AdminDomain'},
		system				=> {class => 'CIM_ComputerSystem'},
		modular				=> {class => 'CIM_ComputerSystem', where=>'OtherDedicatedDescriptions="Modular" and Dedicated="Other"'},
		storage				=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Storage"'},
		router				=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Router"'},
		switch				=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Switch"'},
		hub					=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Hub"'},
		firewall			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Firewall"'},
		printserver			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Print"'},
		accessserver		=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Access Server"'},
		ioserver			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="I/O"'},
		webcache			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Web Caching"'},
		management			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Management"'},
		blockserver			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Block Server"'},
		fileserver			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="File Server"'},
		mobile				=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Mobile User Device"'},
		repeater			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Repeater"'},
		bridge				=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Bridge/Extender"'},
		extender			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Bridge/Extender"'},
		gateway				=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Gateway"'},
		storagevlizer		=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Storage Virtualizer"'},
		medialib			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Media Library"'},
		nashead				=> {class => 'CIM_ComputerSystem', where=>'Dedicated="NAS Head"'},
		nas					=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Self-contained NAS"'},
		ups					=> {class => 'CIM_ComputerSystem', where=>'Dedicated="UPS"'},
		ipphone				=> {class => 'CIM_ComputerSystem', where=>'Dedicated="IP Phone"'},
		map					=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Manageability Access Point"'},
		sp					=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Management Controller"'},
		chassismgr			=> {class => 'CIM_ComputerSystem', where=>'Dedicated="Chassis Manager"'},
		alarm				=> {class => 'CIM_AlarmDevice'},
		battery				=> {class => 'CIM_Battery'},
		cd					=> {class => 'CIM_CDROMDrive'},
		cooling				=> {class => 'CIM_CoolingDevice'},
		daport				=> {class => 'CIM_DAPort'},
		diskdrive			=> {class => 'CIM_DiskDrive'},
		floppy				=> {class => 'CIM_DisketteDrive'},
		diskpartition		=> {class => 'CIM_DiskPartition'},
		display				=> {class => 'CIM_Display'},
		dvd					=> {class => 'CIM_DVDDrive'},
		fan					=> {class => 'CIM_Fan'},
		fcport				=> {class => 'CIM_FCPort'},
		heatpipe			=> {class => 'CIM_HeatPipe'},
		ibport				=> {class => 'CIM_IBPort'},
		keyboard			=> {class => 'CIM_Keyboard'},
		disk				=> {class => 'CIM_LogicalDisk'},
		logicalmodule		=> {class => 'CIM_LogicalModule'},
		devicetray			=> {class => 'CIM_LogicalModule', where=>'LogicalModuleType="Device Tray"'},
		linecard			=> {class => 'CIM_LogicalModule', where=>'LogicalModuleType="Line Card"'},
		blademodule			=> {class => 'CIM_LogicalModule', where=>'LogicalModuleType="Blade"'},
		logicalport			=> {class => 'CIM_LogicalPort'},
		mediaaccess			=> {class => 'CIM_MediaAccessDevice'},
		memory				=> {class => 'CIM_Memory'},
		modem				=> {class => 'CIM_Modem'},
		netport				=> {class => 'CIM_NetworkPort'},
		wifiport			=> {class => 'CIM_WirelessPort'},
		enetport			=> {class => 'CIM_EthernetPort'},
		pcidev				=> {class => 'CIM_PCIDevice'},
		pcibridge			=> {class => 'CIM_PCIBridge'},
		pointer				=> {class => 'CIM_PointingDevice'},
		mouse				=> {class => 'CIM_PointingDevice', where=>'PointingType="Mouse"'},
		trackball			=> {class => 'CIM_PointingDevice', where=>'PointingType="Track Ball"'},
		touchpad			=> {class => 'CIM_PointingDevice', where=>'PointingType="Touch Pad"'},
		touchscreen			=> {class => 'CIM_PointingDevice', where=>'PointingType="Touch Screen"'},
		portctlr			=> {class => 'CIM_PortController'},
		nic					=> {class => 'CIM_PortController', where=>'ControllerType="Ethernet"'},
		hca					=> {class => 'CIM_PortController', where=>'ControllerType="IB"'},
		tca					=> {class => 'CIM_PortController', where=>'ControllerType="IB"'},
		hba					=> {class => 'CIM_PortController', where=>'ControllerType="FC"'},
		pwrsupply			=> {class => 'CIM_PowerSupply'},
		printer				=> {class => 'CIM_Printer'},
		cpu					=> {class => 'CIM_Processor'},
		refrigeration		=> {class => 'CIM_Refrigeration'},
		scsiprotctlr		=> {class => 'CIM_SCSIProtocolController'},
		sensor				=> {class => 'CIM_Sensor'},
		currentsensor		=> {class => 'CIM_Sensor', where=>'SensorType="Current"'},
		tachsensor			=> {class => 'CIM_Sensor', where=>'SensorType="Tachometer"'},
		tempsensor			=> {class => 'CIM_Sensor', where=>'SensorType="Temperature"'},
		voltsensor			=> {class => 'CIM_Sensor', where=>'SensorType="Voltage"'},
		countersensor		=> {class => 'CIM_Sensor', where=>'SensorType="Counter"'},
		switchsensor		=> {class => 'CIM_Sensor', where=>'SensorType="Switch"'},
		locksensor			=> {class => 'CIM_Sensor', where=>'SensorType="Lock"'},
		humiditysensor		=> {class => 'CIM_Sensor', where=>'SensorType="Humidity"'},
		airsensor			=> {class => 'CIM_Sensor', where=>'SensorType="Air Flow"'},
		presencesensor		=> {class => 'CIM_Sensor', where=>'SensorType="Presence"'},
		smokesensor			=> {class => 'CIM_Sensor', where=>'SensorType="Smoke Detection"'},
		numsensor			=> {class => 'CIM_NumericSensor'},
		ncurrentsensor		=> {class => 'CIM_NumericSensor', where=>'SensorType="Current"'},
		ntachsensor			=> {class => 'CIM_NumericSensor', where=>'SensorType="Tachometer"'},
		ntempsensor			=> {class => 'CIM_NumericSensor', where=>'SensorType="Temperature"'},
		nvoltsensor			=> {class => 'CIM_NumericSensor', where=>'SensorType="Voltage"'},
		ncountersensor		=> {class => 'CIM_NumericSensor', where=>'SensorType="Counter"'},
		nswitchsensor		=> {class => 'CIM_NumericSensor', where=>'SensorType="Switch"'},
		nlocksensor			=> {class => 'CIM_NumericSensor', where=>'SensorType="Lock"'},
		nhumiditysensor		=> {class => 'CIM_NumericSensor', where=>'SensorType="Humidity"'},
		nairsensor			=> {class => 'CIM_NumericSensor', where=>'SensorType="Air Flow"'},
		npresencesensor		=> {class => 'CIM_NumericSensor', where=>'SensorType="Presence"'},
		nsmokesensor		=> {class => 'CIM_NumericSensor', where=>'SensorType="Smoke Detection"'},
		spiport				=> {class => 'CIM_SPIPort'},
		storagevol			=> {class => 'CIM_StorageVolume'},
		storageext			=> {class => 'CIM_StorageExtent'},
		serialport			=> {class => 'CIM_SerialPort'},
		tapedrive			=> {class => 'CIM_TapeDrive'},
		usbport				=> {class => 'CIM_USBPort'},
		watchdog			=> {class => 'CIM_WatchDog'},
		portctrl			=> {class => 'CIM_PortController'},
		bootsvc				=> {class => 'CIM_BootService'},
		clpsvc				=> {class => 'CIM_CLPService'},
		ipcfgsvc			=> {class => 'CIM_IPConfigurationService'},
		pwrmgtsvc			=> {class => 'CIM_PowerManagementService'},
		shareddevicesvc		=> {class => 'CIM_SharedDeviceManagementService'},
		swinstallsvc		=> {class => 'CIM_SoftwareInstallationService'},
		sshsvc				=> {class => 'CIM_SSHService'},
		storagecfgsvc		=> {class => 'CIM_StorageConfigurationService'},
		telnetsvc			=> {class => 'CIM_TelnetService'},
		textredirectsvc		=> {class => 'CIM_TextRedirectionService'},
		timesvc				=> {class => 'CIM_TimeService'},
		protoendpt			=> {class => 'CIM_ProtocolEndpoint'},
		ipendpt				=> {class => 'CIM_IPProtocolEndpoint'},
		dhcpendpt			=> {class => 'CIM_DHCPProtocolEndpoint'},
		dnsendpt			=> {class => 'CIM_DNSProtocolEndpoint'},
		remotesap			=> {class => 'CIM_RemoteServiceAccessPoint'},
		dnsserver			=> {class => 'CIM_RemoteServiceAccessPoint', where=>'AccessContext="DNS Server"'},
		dhcpserver			=> {class => 'CIM_RemoteServiceAccessPoint', where=>'AccessContext="DHCP Server"'},
		gateway				=> {class => 'CIM_RemoteServiceAccessPoint', where=>'AccessContext="Default Gateway"'},
		lanendpt			=> {class => 'CIM_LANEndpoint'},
		remoteport			=> {class => 'CIM_RemotePort'},
		scsiendpt			=> {class => 'CIM_SCSIProtocolEndPoint'},
		serviceuri			=> {class => 'CIM_ServiceAccessURI'},
		textredirectsap		=> {class => 'CIM_TextRedirectionServiceAccessPoint'},
		pkg					=> {class => 'CIM_PhysicalPackage'},
		bladepkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Blade"'},
		bladexpkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Blade Expansion"'},
		diskpkg				=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Storage Media Package"'},
		fanpkg				=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Fan"'},
		pwrpkg				=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Power Supply"'},
		rackpkg				=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Rack"'},
		chassispkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Chassis/Frame"'},
		framepkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Chassis/Frame"'},
		backplanepkg		=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Crossconnect/Backplane"'},
		sensorpkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Sensor"'},
		modulepkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Module/Card"'},
		cardpkg				=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Module/Card"'},
		batterypkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Battery"'},
		cpupkg				=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Processor"'},
		memorypkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Memory"'},
		storagepkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Storage Media Package"'},
		pwrsrcpkg			=> {class => 'CIM_PhysicalPackage', where=>'PackageType="Power Source/Generator"'},
		frame				=> {class => 'CIM_PhysicalFrame'},
		rack				=> {class => 'CIM_Rack'},
		chassis				=> {class => 'CIM_Chassis'},
		laptop				=> {class => 'CIM_Chassis', where=>'ChassisPackageType="LapTop"'},
		desktop				=> {class => 'CIM_Chassis', where=>'ChassisPackageType="Desktop"'},
		tower				=> {class => 'CIM_Chassis', where=>'ChassisPackageType="Tower"'},
		storagechas			=> {class => 'CIM_Chassis', where=>'ChassisPackageType="Storage Chassis"'},
		notebook			=> {class => 'CIM_Chassis', where=>'ChassisPackageType="Notebook"'},
		mainchassis			=> {class => 'CIM_Chassis', where=>'ChassisPackageType="Main System Chassis"'},
		expansion			=> {class => 'CIM_Chassis', where=>'ChassisPackageType="Bus Expansion Chassis"'},
		peripheralchassis	=> {class => 'CIM_Chassis', where=>'ChassisPackageType="Peripheral Chassis"'},
		subchassis			=> {class => 'CIM_Chassis', where=>'ChassisPackageType="SubChassis"'},
		card				=> {class => 'CIM_Card'},
		buscard				=> {class => 'CIM_SystemBusCard'},
		pcicard				=> {class => 'CIM_SystemBusCard', where=>'BusType="PCI"'},
		eisacard			=> {class => 'CIM_SystemBusCard', where=>'BusType="EISA"'},
		vesacard			=> {class => 'CIM_SystemBusCard', where=>'BusType="VESA"'},
		pcmciacard			=> {class => 'CIM_SystemBusCard', where=>'BusType="PCMCIA" or BusType="PCMCIA Type I" or BusType="PCMCIA Type II" or BusType="PCMCIA Type III"'},
		accesscard			=> {class => 'CIM_SystemBusCard', where=>'BusType="Access.bus"'},
		nubuscard			=> {class => 'CIM_SystemBusCard', where=>'BusType="NuBus"'},
		agpcard				=> {class => 'CIM_SystemBusCard', where=>'BusType="AGP"'},
		vmecard				=> {class => 'CIM_SystemBusCard', where=>'BusType="VME Bus"'},
		pccard				=> {class => 'CIM_SystemBusCard', where=>'BusType="PC-98" or BusType="PC-98-Hireso" or BusType="PC-H98" or BusType="PC-98Note" or BusType="PC-98Full"'},
		pcixcard			=> {class => 'CIM_SystemBusCard', where=>'BusType="PCI-X"'},
		pciecard			=> {class => 'CIM_SystemBusCard', where=>'BusType="PCI-E"'},
		sbuscard			=> {class => 'CIM_SystemBusCard', where=>'BusType="Sbus IEEE 1396-1993 32 bit" or BusType="Sbus IEEE 1396-1993 64 bit"'},
		isacard				=> {class => 'CIM_SystemBusCard', where=>'BusType="ISA"'},
		mcacard				=> {class => 'CIM_SystemBusCard', where=>'BusType="MCA"'},
		giocard				=> {class => 'CIM_SystemBusCard', where=>'BusType="GIO"'},
		xiocard				=> {class => 'CIM_SystemBusCard', where=>'BusType="XIO"'},
		hiocard				=> {class => 'CIM_SystemBusCard', where=>'BusType="HIO"'},
		pmccard				=> {class => 'CIM_SystemBusCard', where=>'BusType="PMC"'},
		ibcard				=> {class => 'CIM_SystemBusCard', where=>'BusType="Infiniband"'},
		component			=> {class => 'CIM_PhysicalComponent'},
		chip 				=> {class => 'CIM_Chip'},
		propchip			=> {class => 'CIM_Chip', where=>'FormFactor="Proprietary Chip"'},
		sip					=> {class => 'CIM_Chip', where=>'FormFactor="SIP"'},
		dip					=> {class => 'CIM_Chip', where=>'FormFactor="DIP"'},
		zip					=> {class => 'CIM_Chip', where=>'FormFactor="ZIP"'},
		soj					=> {class => 'CIM_Chip', where=>'FormFactor="SOJ"'},
		simm				=> {class => 'CIM_Chip', where=>'FormFactor="SIMM"'},
		dimm				=> {class => 'CIM_Chip', where=>'FormFactor="DIMM"'},
		tsop				=> {class => 'CIM_Chip', where=>'FormFactor="TSOP"'},
		pga					=> {class => 'CIM_Chip', where=>'FormFactor="PGA"'},
		rimm				=> {class => 'CIM_Chip', where=>'FormFactor="RIMM"'},
		sodimm				=> {class => 'CIM_Chip', where=>'FormFactor="SODIMM"'},
		srimm				=> {class => 'CIM_Chip', where=>'FormFactor="SRIMM"'},
		smd					=> {class => 'CIM_Chip', where=>'FormFactor="SMD"'},
		ssmp				=> {class => 'CIM_Chip', where=>'FormFactor="SSMP"'},
		qfp					=> {class => 'CIM_Chip', where=>'FormFactor="QFP"'},
		tqfp				=> {class => 'CIM_Chip', where=>'FormFactor="TQFP"'},
		soic				=> {class => 'CIM_Chip', where=>'FormFactor="SOIC"'},
		lc					=> {class => 'CIM_Chip', where=>'FormFactor="LCC"'},
		plcc				=> {class => 'CIM_Chip', where=>'FormFactor="PLCC"'},
		bga					=> {class => 'CIM_Chip', where=>'FormFactor="BGA"'},
		fpbga				=> {class => 'CIM_Chip', where=>'FormFactor="FPBGA"'},
		lga					=> {class => 'CIM_Chip', where=>'FormFactor="LGA"'},
		pmem				=> {class => 'CIM_PhysicalMemory'},
		ram					=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="RAM"'},
		dram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="DRAM"'},
		synchdram			=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="Synchronous DRAM"'},
		cache				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="Cache DRAM"'},
		edo					=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="EDO"'},
		edram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="EDRAM"'},
		vram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="VRAM"'},
		sram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="SRAM"'},
		flash				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="Flash"'},
		eeprom				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="EEPROM"'},
		eprom				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="EPROM"'},
		cdram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="CDRAM"'},
		sdram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="SDRAM"'},
		sgram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="SGRAM"'},
		rdram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="RDRAM"'},
		ddr					=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="DDR"'},
		bram				=> {class => 'CIM_PhysicalMemory', where=>'MemoryType="BRAM"'},
		connector			=> {class => 'CIM_PhysicalConnector'},
		slot				=> {class => 'CIM_Slot'},
	};
	$self->{UFContainers}={
		CIM_AdminDomain				=> [{association=>'CIM_OwningCollectionElement', contained=>'CIM_ConcreteCollection'}],
		CIM_ConcreteCollection		=> [{association=>'CIM_MemberOfCollection', contained=>'CIM_PhysicalPackage'}],
		CIM_Rack					=> [{association=>'CIM_ChassisInRack', contained=>'CIM_Chassis'}],
		CIM_Chassis					=> [{association=>'CIM_PackageInChassis', contained=>'CIM_PhysicalPackage'}],
		CIM_PhysicalPackage			=> [{association=>'CIM_Container', contained=>'CIM_PhysicalElement'},
										{association=>'CIM_PackagedComponent', contained=>'CIM_PhysicalComponent'},
										{association=>'CIM_ConnectorOnPackage', contained=>'CIM_PhysicalConnector'}],
		CIM_PhysicalConnector		=> [{association=>'CIM_PackageInConnector', contained=>'CIM_PhysicalPackage'}],
		CIM_Slot					=> [{association=>'CIM_PackageInSlot', contained=>'CIM_PhysicalPackage'},
										{association=>'CIM_CardInSlot', contained=>'CIM_Card'}],
		CIM_Card					=> [{association=>'CIM_CardOnCard', contained=>'CIM_Card'}],
		CIM_AdminDomain				=> [{association=>'CIM_SystemComponent', contained=>'CIM_ComputerSystem'}],
		CIM_ComputerSystem			=> [{association=>'CIM_SystemComponent', contained=>'CIM_ComputerSystem'},
										{association=>'CIM_SystemDevice', contained=>'CIM_LogicalDevice'},
										{association=>'CIM_HostedService', contained=>'CIM_Service'},
										{association=>'CIM_HostedAccessPoint', contained=>'CIM_ServiceAccessPoint'},
										{association=>'CIM_OwningCollectionElement', contained=>'CIM_ConcreteCollection'},
										{association=>'CIM_HostedPool', contained=>'CIM_StoragePool'}],
		CIM_ConcreteCollection		=> [{association=>'CIM_MemberOfCollection', contained=>'CIM_ManagedElement'},
										{association=>'CIM_OrderedMemberOfCollection', contained=>'CIM_ManagedElement'}],
		CIM_BootConfigSetting		=> [{association=>'CIM_ConcreteComponent', contained=>'CIM_SettingData'},
										{association=>'CIM_OrderedComponent', contained=>'CIM_BootSourceSetting'},
										{association=>'CIM_ConcreteComponent', contained=>'CIM_SettingData'}],
		CIM_RecordLog				=> [{association=>'CIM_LogManagesRecord', contained=>'CIM_LogRecord'}],
		CIM_ComputerSystem			=> [{association=>'CIM_HostedJobQueue', contained=>'CIM_JobQueue'}],
		CIM_JobQueue				=> [{association=>'CIM_JobDestinationJobs', contained=>'CIM_ConcreteJob'}],
		CIM_ProtocolEndpoint		=> [{association=>'CIM_BindsTo', contained=>'CIM_ProtocolEndpoint'},
										{association=>'CIM_RemoteAccessAvailableToElement', contained=>'CIM_RemoteServiceAccessPoint'}],
		CIM_EthernetPort			=> [{association=>'CIM_PortImplementsEndpoint', contained=>'CIM_LANEndpoint'}],
		CIM_IPAssignmentSettingData	=> [{association=>'CIM_OrderedComponent', contained=>'CIM_IPAssignmentSettingData'}],
	# Non-standard...
		CIM_RegisteredProfile		=> [{association=>'CIM_ElementConformsToProfile', contained=>'CIM_ComputerSystem'}],
	};
	$self->{uricache}={};

	bless($self, $self->{CLASS});
	return($self);
}

sub instance_of
{
	my $self=shift;
	my $class=shift;
	my $lcc=lc($class);
	my $classref;

	if(!defined $class) {
		carp("$self->{CLASS}\->instance_of() called without a class name");
		return;
	}

	if(defined $self->{MODEL}{classes}{$lcc}) {
		$classref=$self->{MODEL}{classes}{$lcc};
	}
	elsif(defined $self->{MODEL}{associations}{$lcc}) {
		$classref=$self->{MODEL}{associations}{$lcc};
	}
	elsif(defined $self->{MODEL}{indications}{$lcc}) {
		$classref=$self->{MODEL}{indications}{$lcc};
	}
	if(!defined $classref) {
		# Now, if there is a GetClass() method, invoke it and add the class to the
		# model.
		my $cl=$self->GetClass($class);
		if(defined $cl && $cl->{name} eq lc($class)) {
			if($cl->{qualifiers}{association} eq 'true') {
				$self->{MODEL}{associations}{lc($cl->{name})}=$cl;
			}
			elsif($cl->{qualifiers}{indication} eq 'true') {
				$self->{MODEL}{indications}{lc($cl->{name})}=$cl;
			}
			else {
				$self->{MODEL}{classes}{lc($cl->{name})}=$cl;
			}
			return $self->instance_of($cl->{name});
		}
		else {
			carp("Unknown class '$class' requested from $self->{CLASS}");
			return;
		}
	}

	my $instance=DMTF::CIM::Instance->new(class=>$classref,parent=>$self);
	return($instance);
}

sub class_tag_alias
{
	my $self=shift;
	my $class=shift;
	my $lcc=lc($class);
	my $alias=shift;

	if(defined $self->{MODEL}{classes}{$lcc}) {
		$class=$self->{MODEL}{classes}{$lcc}{name};
	}
	elsif(defined $self->{MODEL}{associations}{$lcc}) {
		$class=$self->{MODEL}{associations}{$lcc}{name};
	}
	elsif(defined $self->{MODEL}{indications}{$lcc}) {
		$class=$self->{MODEL}{indications}{$lcc}{name};
	}
	if(defined $alias) {
		my $lc=lc($alias);
		if(defined $self->{UFcT}{$lc} && $self->{UFcT}{$lc}{class} ne $class) {
			carp("Illegal attempt to overwrite definition of UFcT $lc ($self->{UFcT}{$lc}{class}) with $class");
		}
		else {
			$self->{UFcT}{$lc}{class}=$class;
		}
	}
	else {
		foreach my $check_alias (keys %{$self->{UFcT}}) {
			if($self->{UFcT}{$check_alias}{class} eq $class) {
				next if lc($class) eq $check_alias;
				next if defined $self->{UFcT}{$check_alias}{where};
				$alias=$check_alias;
				last;
			}
		}
		$alias = $class unless defined $alias;
	}
	return $alias;
}

sub cache_uri_class
{
	my $self=shift;
	my $uri=shift;

	if($uri =~ m|(?:(?:[^:/?#]+):)?(?://(?:[^/?#]*))?([^?#]*)(?:\?(?:[^#]*))?(?:#(?:.*))?|) {
		my $path=$1;
		if($path=~/^[^:]*?:([^.]+?)\./) {
			my $class=$1;
			$self->class_tag_alias($class, lc($class));
		}
	}
}

sub resolve_class_tag {
	my $self=shift;
	my %args=@_;
	$args{assoc}=0 if(!defined $args{assoc});

	if(!defined $args{tag}) {
		carp("$self->{CLASS}\->resolve_class_tag() requires a tag argument.");
		return;
	}

	my $lcc=lc($args{tag});
	# First, check the class tag aliases.
	if(defined $self->{UFcT}{$lcc} && defined $self->{UFcT}{$lcc}{class}) {
		return $self->{UFcT}{$lcc}{class};
	}

	# Next, check for an exact model match
	if(defined $self->{MODEL}{classes}{$lcc}) {
		$self->class_tag_alias($self->{MODEL}{classes}{$lcc}{name}, lc($self->{MODEL}{classes}{$lcc}{name}));
		return $self->{MODEL}{classes}{$lcc}{name};
	}
	elsif(defined $self->{MODEL}{associations}{$lcc}) {
		$self->class_tag_alias($self->{MODEL}{associations}{$lcc}{name}, lc($self->{MODEL}{associations}{$lcc}{name}));
		return $self->{MODEL}{associations}{$lcc}{name};
	}
	elsif(defined $self->{MODEL}{indications}{$lcc}) {
		$self->class_tag_alias($self->{MODEL}{indications}{$lcc}{name}, lc($self->{MODEL}{indications}{$lcc}{name}));
		return $self->{MODEL}{indications}{$lcc}{name};
	}

	# Now we assume we're working with incomplete data... either the model
	# is missing the specified class, or the class tag alias is undefined.
	# Since CIM classes are in the SCHEMA_Name format, if there is no
	# underscore, it is not a missing class, and must be a missing tag.
	if($args{tag} !~ /_/) {
		carp("Invalid UFcT $args{tag}");
		return;
	}

	# Now, if there is a GetClass() method, invoke it and add the class to the
	# model.
	my $class=$self->GetClass($args{tag});
	if(defined $class && $class->{name} eq lc($args{tag})) {
		if($class->{qualifiers}{association} eq 'true') {
			$self->{MODEL}{associations}{lc($class->{name})}=$class;
		}
		elsif($class->{qualifiers}{indication} eq 'true') {
			$self->{MODEL}{indications}{lc($class->{name})}=$class;
		}
		else {
			$self->{MODEL}{classes}{lc($class->{name})}=$class;
		}
		$self->class_tag_alias($class->{name}, lc($class->{name}));
		return $class->{name};
	}

	# Still don't have the class name.  Try to enumerate associated/association
	# instances to find correct capitalization.

	my @uri_list;
	my %enum_args;
	$enum_args{via}=$args{via} if(defined $args{via});
	if(defined $args{uri}) {
		$enum_args{uri}=$args{uri};
	}
	else {
		$enum_args{uri}='/interop';
	}
	$enum_args{class}=$args{tag} if(defined $args{tag});
	my $uri_has_instance=0;
	$uri_has_instance=1 if($enum_args{uri} =~ /:[^.]+\..*$/);
	if($uri_has_instance) {
		if($args{assoc}) {
			delete $enum_args{class};
			@uri_list=$self->GetReferencingInstancePaths(%enum_args);
		}
	}
	elsif($uri_has_instance) {
		if(!$args{assoc}) {
			@uri_list=$self->GetAssociatedInstancePaths(%enum_args);
		}
	}
	else {
		@uri_list=$self->GetClassInstancePaths(%enum_args);
	}

	foreach my $uri (@uri_list) {
		$self->cache_uri_class($uri);
	}
	if(defined $self->{UFcT}{lc($args{tag})} && defined $self->{UFcT}{lc($args{tag})}{class}) {
		return $self->{UFcT}{lc($args{tag})}{class};
	}
	carp("Unable to resolve $args{tag}");
	return;
}

sub normalize_path
{
	my $self=shift;
	my $path=shift;

	# Change all sequences of slashes and backslashes to a single slash
	$path=~s/[\/\\]+/\//g;

	# Remove trailing /
	$path =~ s|/$||g;

	# Remove /.
	while($path =~ s|(.)/\./|$1/|g){};

	# Remove /.=
	while($path =~ s|(.)/\.=|$1=|g){};

	# Remove trailing /.
	$path =~ s|(/\.)+$||g;

	# Remove /XXX/..
	while($path =~ s|/[^/.]+/\.\./|/|g){};

	# Remove /Thing.Thing/..
	while($path =~ s|/[^/.]+\.[^/]*/\.\./|/|g){};

	# Remove /Thing.Thing/..
	while($path =~ s|/[^/]*\.[^/.]*/\.\./|/|g){};

	# Remove /.../..
	while($path =~ s|/\.{3,}/\.\./|/|g){};

	# Remove trailing /XXX/..
	while($path =~ s|/[^/]+/\.\.$||g){};

	# Zero-length becomes root.
	if($path eq '') {
		$path='/';
	}

	return $path;
}

sub UFiP_to_URI {
	my $self=shift;
	my $UFP=shift;
	my $rooturi=shift;
	if(!defined $rooturi) {
		$rooturi=$self->{uricache}{'/'} if(defined $self->{uricache}{'/'});
	}

	if(!defined $rooturi) {
		carp("$self->{CLASS}\->UFiP_to_URI() called with no root URI specified");
		return;
	}
	my $currenturi=$rooturi;
	my $currentpath='';
	my @repsonse;
	my @urilist;
	my $loops=0;

	# Normalize...
	$UFP=$self->normalize_path($UFP);
	if($UFP !~ m|^/|) {
		carp "Path error: Path $UFP is not absolute";
		return;
	}

	# Now fix up associations (ie: path to association instance)
	$UFP =~ s|=>|/-=|g;

	# Now, split on slashes...
	my @elements=split(/\//, $UFP);
	# And remove the root....
	shift @elements;

	while(my $element = shift(@elements)) {
		my $targetclass;
		my $targetisassoc=0;
		my $tag;
		my $id;
		my $via;

		push @urilist,$currenturi;

		if($element =~ /^(-=)?(.+?)([0-9*]*)$/) {
			$tag=$2;
			$id=$3;

			if(defined $1 && $1 eq '-=') {
				$targetisassoc=1;
			}

			if(!defined $id || $id eq '' && $#elements != -1) {
				# Really?  You expect people to understand that error message?
				carp("Invalid Path - contains non-terminal UFcT");
				return;
			}
			if($3 eq '*' && $#elements != -1) {
				# Really?  You expect people to understand that error message?
				carp("Invalid Path - contains non-terminal wildcard");
				return;
			}
		}
		else {
			carp("Impossible error... $element did not match /^(-=)?(.+?)([0-9*]*)\$/");
			return;
		}

		$targetclass=$self->resolve_class_tag(tag=>$tag, uri=>$currenturi, assoc=>$targetisassoc, via=>$via);

		if(!defined $targetclass) {
			return;
		}

		my $pathelement="$tag$id";
		if($targetisassoc) {
			$currentpath .= "=>$pathelement";
		}
		else {
			if($currentpath =~ /=>[^\/]+$/) {
				$currentpath .= "=>$pathelement";
			}
			else {
				$currentpath .= "/$pathelement";
			}
		}

		my $nametag=$currentpath;
		$nametag =~ s/[0-9*]+$//;
		if(!defined $id || $id eq '') {
			my($scheme, $authority, $path, $query, $fragment) = $currenturi =~ m|(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?|;
			$path =~ s/:.*$//;
			$currenturi='';
			if(defined $scheme && $scheme ne '' && defined $authority && $authority ne '') {
				$currenturi="$scheme://$authority";
			}
			$currenturi.="$path:$targetclass";
		}
		elsif($id eq '*') {
			my @new_urilist;
			if($targetisassoc) {
				@new_urilist=$self->GetReferencingInstancePaths(uri=>$currenturi, class=>$targetclass, via=>$via);
			}
			else {
				@new_urilist=$self->GetAssociatedInstancePaths(uri=>$currenturi, class=>$targetclass, via=>$via);
			}
			foreach my $i (0..$#new_urilist) {
				$self->{uricache}{$nametag.($i+1)}=$new_urilist[$i];
				$self->cache_uri_class($new_urilist[$i]);
			}
			return [@new_urilist];
		}
		else {
			# Now get the nth match.
			if(!defined $self->{uricache}{$currentpath}) {
				my @new_urilist;

				if($targetisassoc) {
					@new_urilist=$self->GetReferencingInstancePaths(uri=>$currenturi, class=>$targetclass, via=>$via);
				}
				else {
					@new_urilist = $self->GetAssociatedInstancePaths(uri=>$currenturi, class=>$targetclass, via=>$via);
				}
				foreach my $i (0..$#new_urilist) {
					$self->{uricache}{$nametag.($i+1)}=$new_urilist[$i];
					$self->cache_uri_class($new_urilist[$i]);
				}
			}
			if(!defined $self->{uricache}{$currentpath}) {
				carp("Invalid UFiS specified at end of $currentpath");
				return;
			}
			$currenturi=$self->{uricache}{$currentpath};

			foreach my $turi (@urilist) {
				if($turi eq $currenturi) {
					$loops++;
				}
			}
		}
	}

	carp "Path error: Instance loop detected." if $loops;
	return $currenturi;
}

sub clear_uri_cache
{
	my $self=shift;
	$self->{uricache}={};
}

sub cache_uri_path
{
	my $self=shift;
	my $path=shift;
	my $uri=shift;
	$self->{uricache}{$path}=$uri;
}

sub parse_mof
{
	my $self=shift;
	my $path=shift;
	my $clear=shift || 0;
	require DMTF::CIM::MOF;

	if(defined $DMTF::CIM::MOF::{parse_MOF}) {
		$self->{MODEL} = DMTF::CIM::MOF::parse_MOF($path, $clear?undef:$self->{MODEL});
	}
}

###########################
# Generic Operation Stubs #
###########################
sub GetClass
{
	return;
}

sub GetInstance
{
	return;
}

sub ModifyInstance
{
	return;
}

sub DeleteInstance
{
	return;
}

sub CreateInstance
{
	return;
}

sub GetClassInstancePaths
{
	return;
}

sub GetReferencingInstancePaths
{
	return;
}

sub GetAssociatedInstancePaths
{
	return;
}

sub GetClassInstancesWithPath
{
	return;
}

sub GetReferencingInstancesWithPath
{
	return;
}

sub GetAssociatedInstancesWithPath
{
	return;
}

sub InvokeMethod
{
	return;
}

#####################
# Friendly Wrappers #
#####################
sub get
{
	my $self=shift;
	return $self->GetInstance(@_);
}

sub put
{
	my $self=shift;
	return $self->ModifyInstance(@_);
}

sub delete
{
	my $self=shift;
	return $self->DeleteInstance(@_);
}

sub create
{
	my $self=shift;
	return $self->CreateInstance(@_);
}

sub class_uris
{
	my $self=shift;
	return $self->GetClassInstancePaths(@_);
}

sub associations
{
	my $self=shift;
	return $self->GetReferencingInstancePaths(@_);
}

sub associated
{
	my $self=shift;
	return $self->GetAssociatedInstancePaths(@_);
}

sub class_instances
{
	my $self=shift;
	return $self->GetClassInstancesWithPath(@_);
}

sub association_instances
{
	my $self=shift;
	return $self->GetReferencingInstancesWithPath(@_);
}

sub associated_instances
{
	my $self=shift;
	return $self->GetAssociatedInstancesWithPath(@_);
}

sub invoke
{
	my $self=shift;
	return $self->InvokeMethod(@_);
}

1; # Magic true value required at end of module
__END__