/******************************************************************************
 *                                                                         
 *               Nimbus auto-generated file
 *               !!! WARNING !!! -- DO NOT DIRECTLY EDIT THE CONTENTS OF THIS FILE.
 *				 Changes will be OVERWRITTEN by NIMBUS.
 *
 *****************************************************************************/

#include "stdafx.h"
#include "CoAgilent34980A.h"
#include "CoAgilent34980AChannel.h"


///////////////////////////////////////////////////////////////
//
//   Repeated capability support
//

HRESULT CObjectModelNode<Agilent34980A, Agilent34980A, Agilent34980A>::InitNode(Agilent34980A* pRoot, Agilent34980A* pParent)
{
	HRESULT hr = S_OK;

	ResetObjectState();
	
	SetClassName(_T("Agilent34980A"));
	SetRoot(pRoot);
	SetParent(pParent);
		
	hr = CreateChildNode<Agilent34980AChannel>(_T("Agilent34980AChannel"));
	if (FAILED(hr)) return hr;

	return hr;
}

HRESULT CObjectModelNode<Agilent34980A, Agilent34980A, Agilent34980A>::CloseNode()			
{
	HRESULT hr = S_OK;
		
	hr = DeleteChildNode<Agilent34980AChannel>(_T("Agilent34980AChannel"));
	if (FAILED(hr)) return hr;

	SetRoot(NULL);
	SetParent(NULL);
	
	return hr;
}


template <>
const CString& GetRepCapClassNameFromClass<Agilent34980AChannel>()
{
	static CString _strRepCapClassName(_T("Agilent34980AChannel"));
	
	return _strRepCapClassName;
}


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDriverIdentity implementation support
//

const CString& CDriver<Agilent34980A, CVisaComIOProvider>::GetDescription()
{
	static CString _strDescription(_T("Agilent 34980A modular switch measurement system."));
	
	return _strDescription;
}

const CString& CDriver<Agilent34980A, CVisaComIOProvider>::GetRevision()
{
	static CString _strRevision(_T("1.3.7.0"));
	
	return _strRevision;
}

const CString& CDriver<Agilent34980A, CVisaComIOProvider>::GetVendor()
{
	static CString _strVendor(_T("Agilent Technologies"));
	
	return _strVendor;
}

const CString& CDriver<Agilent34980A, CVisaComIOProvider>::GetIdentifier()
{
	static CString _strIdentifier(_T("Agilent34980A"));
	
	return _strIdentifier;
}

const CString& CDriver<Agilent34980A, CVisaComIOProvider>::GetGroupCapabilities()
{
	static CString _strGroupCapabilities(_T("IviDmmBase,IviDmmACMeasurement,IviDmmFrequencyMeasurement,IviDmmTemperatureMeasurement,IviDmmThermocouple,IviDmmResistanceTemperatureDevice,IviDmmThermistor,IviDmmMultiPoint,IviDmmTriggerSlope,IviDmmSoftwareTrigger,IviDmmDeviceInfo,IviDmmAutoRangeValue,IviDmmAutoZero,IviDmmPowerLineFrequency,IviSwtchBase,IviSwtchSoftwareTrigger"));
	
	return _strGroupCapabilities;
}

long CDriver<Agilent34980A, CVisaComIOProvider>::GetSpecificationMajorVersion()
{
	return 3;
}

long CDriver<Agilent34980A, CVisaComIOProvider>::GetSpecificationMinorVersion()
{
	return 0;
}

///////////////////////////////////////////////////////////////////////////////
//
//	Instrument models support
//

const CInstrumentModelMap* CInstrumentModelManager::GetInstrumentModelMap()
{
	static CInstrumentModelMap _instrModelMap(
		new CInstrumentModel(_T("34980A"), _T("Default")),
		NULL);

	return &_instrModelMap;
}



///////////////////////////////////////////////////////////////
//
//   Boolean support
//

const CString& GetBooleanTrueCommand()
{
	static CString _strCommand(_T("1"));

	return _strCommand;
}

const CString& GetBooleanFalseCommand()
{
	static CString _strCommand(_T("0"));

	return _strCommand;
}



///////////////////////////////////////////////////////////////
//
//   Enum support
//

template <>
const CEnumSupportedModelMap<Agilent34980AAlarmModeEnum>* GetEnumSupportedModelMap<Agilent34980AAlarmModeEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AAlarmModeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AAlarmModeEnum>* GetEnumCommandMap<Agilent34980AAlarmModeEnum>()
{
	static CEnumCommandMap<Agilent34980AAlarmModeEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AAlarmModeLatch, _T("LATC"), _T("")),
		new CEnumCommand(Agilent34980AAlarmModeTrack, _T("TRAC"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AAutoZeroEnum>* GetEnumSupportedModelMap<Agilent34980AAutoZeroEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AAutoZeroEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AAutoZeroEnum>* GetEnumCommandMap<Agilent34980AAutoZeroEnum>()
{
	static CEnumCommandMap<Agilent34980AAutoZeroEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AAutoZeroOFF, _T("0"), _T("")),
		new CEnumCommand(Agilent34980AAutoZeroONCE, _T("ONCE"), _T("")),
		new CEnumCommand(Agilent34980AAutoZeroON, _T("1"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AFRTDAlphaEnum>* GetEnumSupportedModelMap<Agilent34980AFRTDAlphaEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AFRTDAlphaEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AFRTDAlphaEnum>* GetEnumCommandMap<Agilent34980AFRTDAlphaEnum>()
{
	static CEnumCommandMap<Agilent34980AFRTDAlphaEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AFRTDAlpha85, _T("85"), _T("")),
		new CEnumCommand(Agilent34980AFRTDAlpha91, _T("91"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AHWInterfaceEnum>* GetEnumSupportedModelMap<Agilent34980AHWInterfaceEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AHWInterfaceEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AHWInterfaceEnum>* GetEnumCommandMap<Agilent34980AHWInterfaceEnum>()
{
	static CEnumCommandMap<Agilent34980AHWInterfaceEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AHWInterfaceGPIB, _T("GPIB"), _T("")),
		new CEnumCommand(Agilent34980AHWInterfaceUsb, _T("USB"), _T("")),
		new CEnumCommand(Agilent34980AHWInterfaceLan, _T("LAN"), _T("")),
		new CEnumCommand(Agilent34980AHWInterfaceSockets, _T("SOCK"), _T("")),
		new CEnumCommand(Agilent34980AHWInterfaceTelnet, _T("TELN"), _T("")),
		new CEnumCommand(Agilent34980AHWInterfaceVXI11, _T("VXI11"), _T("")),
		new CEnumCommand(Agilent34980AHWInterfaceWeb, _T("WEB"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AModuleTemperatureEnum>* GetEnumSupportedModelMap<Agilent34980AModuleTemperatureEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AModuleTemperatureEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AModuleTemperatureEnum>* GetEnumCommandMap<Agilent34980AModuleTemperatureEnum>()
{
	static CEnumCommandMap<Agilent34980AModuleTemperatureEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AModuleTemperatureTransducer, _T("TRAN"), _T("")),
		new CEnumCommand(Agilent34980AModuleTemperatureThreshold, _T("TTHR"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AMonitorModeEnum>* GetEnumSupportedModelMap<Agilent34980AMonitorModeEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AMonitorModeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AMonitorModeEnum>* GetEnumCommandMap<Agilent34980AMonitorModeEnum>()
{
	static CEnumCommandMap<Agilent34980AMonitorModeEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AMonitorModeChannel, _T("CHAN"), _T("")),
		new CEnumCommand(Agilent34980AMonitorModeDMM, _T("DMM"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ARJunctionEnum>* GetEnumSupportedModelMap<Agilent34980ARJunctionEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ARJunctionEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ARJunctionEnum>* GetEnumCommandMap<Agilent34980ARJunctionEnum>()
{
	static CEnumCommandMap<Agilent34980ARJunctionEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ARJunctionInternal, _T("INT"), _T("")),
		new CEnumCommand(Agilent34980ARJunctionExternal, _T("EXT"), _T("")),
		new CEnumCommand(Agilent34980ARJunctionFixed, _T("FIX"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ARTDAlphaEnum>* GetEnumSupportedModelMap<Agilent34980ARTDAlphaEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ARTDAlphaEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ARTDAlphaEnum>* GetEnumCommandMap<Agilent34980ARTDAlphaEnum>()
{
	static CEnumCommandMap<Agilent34980ARTDAlphaEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ARTDAlpha85, _T("85"), _T("")),
		new CEnumCommand(Agilent34980ARTDAlpha91, _T("91"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AResolutionEnum>* GetEnumSupportedModelMap<Agilent34980AResolutionEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AResolutionEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AResolutionEnum>* GetEnumCommandMap<Agilent34980AResolutionEnum>()
{
	static CEnumCommandMap<Agilent34980AResolutionEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AResolutionLeast, _T("MAX"), _T("")),
		new CEnumCommand(Agilent34980AResolutionDefault, _T("DEF"), _T("")),
		new CEnumCommand(Agilent34980AResolutionBest, _T("MIN"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ASRQReasonEnum>* GetEnumSupportedModelMap<Agilent34980ASRQReasonEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ASRQReasonEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ASRQReasonEnum>* GetEnumCommandMap<Agilent34980ASRQReasonEnum>()
{
	static CEnumCommandMap<Agilent34980ASRQReasonEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ASRQReasonStbMAV, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonStbErrorQue, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonAlarm1, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonEsrOPC, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonEsrQueryError, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonEsrDeviceError, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonEsrExecutionError, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonEsrCommandError, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonAlarm2, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonQuesVoltage, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonQuesCurrent, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonAlarm3, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonAlarm4, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonAlarmQEmpty, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonQuesResistance, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonQuesTemperature, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonQuesTotalizer, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonQuesMemory, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonAlarmQOV, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonOperScanning, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonOperConfChange, _T(""), _T("")),
		new CEnumCommand(Agilent34980ASRQReasonOperMemThreshold, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ASlopeEnum>* GetEnumSupportedModelMap<Agilent34980ASlopeEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ASlopeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ASlopeEnum>* GetEnumCommandMap<Agilent34980ASlopeEnum>()
{
	static CEnumCommandMap<Agilent34980ASlopeEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ASlopeNegative, _T("NEG"), _T("")),
		new CEnumCommand(Agilent34980ASlopePositive, _T("POS"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AStatusRegisterEnum>* GetEnumSupportedModelMap<Agilent34980AStatusRegisterEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AStatusRegisterEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AStatusRegisterEnum>* GetEnumCommandMap<Agilent34980AStatusRegisterEnum>()
{
	static CEnumCommandMap<Agilent34980AStatusRegisterEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AStatusRegisterStatusByte, _T(""), _T("")),
		new CEnumCommand(Agilent34980AStatusRegisterStandardEvent, _T(""), _T("")),
		new CEnumCommand(Agilent34980AStatusRegisterOperation, _T(""), _T("")),
		new CEnumCommand(Agilent34980AStatusRegisterQuestionable, _T(""), _T("")),
		new CEnumCommand(Agilent34980AStatusRegisterAlarm, _T(""), _T("")),
		new CEnumCommand(Agilent34980AStatusRegisterModule, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AStatusSubRegisterEnum>* GetEnumSupportedModelMap<Agilent34980AStatusSubRegisterEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AStatusSubRegisterEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AStatusSubRegisterEnum>* GetEnumCommandMap<Agilent34980AStatusSubRegisterEnum>()
{
	static CEnumCommandMap<Agilent34980AStatusSubRegisterEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AStatusSubRegisterCondition, _T(""), _T("")),
		new CEnumCommand(Agilent34980AStatusSubRegisterEvent, _T(""), _T("")),
		new CEnumCommand(Agilent34980AStatusSubRegisterEnable, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ATemperatureUnitsEnum>* GetEnumSupportedModelMap<Agilent34980ATemperatureUnitsEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ATemperatureUnitsEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ATemperatureUnitsEnum>* GetEnumCommandMap<Agilent34980ATemperatureUnitsEnum>()
{
	static CEnumCommandMap<Agilent34980ATemperatureUnitsEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ATemperatureUnitsCelcius, _T("C"), _T("")),
		new CEnumCommand(Agilent34980ATemperatureUnitsFahrenheit, _T("F"), _T("")),
		new CEnumCommand(Agilent34980ATemperatureUnitsKelvin, _T("K"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AThermistorEnum>* GetEnumSupportedModelMap<Agilent34980AThermistorEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AThermistorEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AThermistorEnum>* GetEnumCommandMap<Agilent34980AThermistorEnum>()
{
	static CEnumCommandMap<Agilent34980AThermistorEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AThermistor2252, _T("2252"), _T("")),
		new CEnumCommand(Agilent34980AThermistor5000, _T("5000"), _T("")),
		new CEnumCommand(Agilent34980AThermistor10000, _T("10000"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AThermocoupleEnum>* GetEnumSupportedModelMap<Agilent34980AThermocoupleEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AThermocoupleEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AThermocoupleEnum>* GetEnumCommandMap<Agilent34980AThermocoupleEnum>()
{
	static CEnumCommandMap<Agilent34980AThermocoupleEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AThermocoupleBType, _T("B"), _T("")),
		new CEnumCommand(Agilent34980AThermocoupleEType, _T("E"), _T("")),
		new CEnumCommand(Agilent34980AThermocoupleJType, _T("J"), _T("")),
		new CEnumCommand(Agilent34980AThermocoupleKType, _T("K"), _T("")),
		new CEnumCommand(Agilent34980AThermocoupleNType, _T("N"), _T("")),
		new CEnumCommand(Agilent34980AThermocoupleRType, _T("R"), _T("")),
		new CEnumCommand(Agilent34980AThermocoupleSType, _T("S"), _T("")),
		new CEnumCommand(Agilent34980AThermocoupleTType, _T("T"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ATimeOffsetEnum>* GetEnumSupportedModelMap<Agilent34980ATimeOffsetEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ATimeOffsetEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ATimeOffsetEnum>* GetEnumCommandMap<Agilent34980ATimeOffsetEnum>()
{
	static CEnumCommandMap<Agilent34980ATimeOffsetEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ATimeOffsetAbsolute, _T("ABS"), _T("")),
		new CEnumCommand(Agilent34980ATimeOffsetRelative, _T("REL"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ATransducerEnum>* GetEnumSupportedModelMap<Agilent34980ATransducerEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ATransducerEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ATransducerEnum>* GetEnumCommandMap<Agilent34980ATransducerEnum>()
{
	static CEnumCommandMap<Agilent34980ATransducerEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ATransducerTcouple, _T("TC"), _T("")),
		new CEnumCommand(Agilent34980ATransducerRTD, _T("RTD"), _T("")),
		new CEnumCommand(Agilent34980ATransducerFRTD, _T("FRTD"), _T("")),
		new CEnumCommand(Agilent34980ATransducerThermistor, _T("THER"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ATriggerSourceEnum>* GetEnumSupportedModelMap<Agilent34980ATriggerSourceEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ATriggerSourceEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ATriggerSourceEnum>* GetEnumCommandMap<Agilent34980ATriggerSourceEnum>()
{
	static CEnumCommandMap<Agilent34980ATriggerSourceEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ATriggerSourceBus, _T("BUS"), _T("")),
		new CEnumCommand(Agilent34980ATriggerSourceImmediate, _T("IMM"), _T("")),
		new CEnumCommand(Agilent34980ATriggerSourceExternal, _T("EXT"), _T("")),
		new CEnumCommand(Agilent34980ATriggerSourceAlarm1, _T("ALAR1"), _T("")),
		new CEnumCommand(Agilent34980ATriggerSourceAlarm2, _T("ALAR2"), _T("")),
		new CEnumCommand(Agilent34980ATriggerSourceAlarm3, _T("ALAR3"), _T("")),
		new CEnumCommand(Agilent34980ATriggerSourceAlarm4, _T("ALAR4"), _T("")),
		new CEnumCommand(Agilent34980ATriggerSourceTimer, _T("TIM"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980AWireModeEnum>* GetEnumSupportedModelMap<Agilent34980AWireModeEnum>()
{
	static CEnumSupportedModelMap<Agilent34980AWireModeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980AWireModeEnum>* GetEnumCommandMap<Agilent34980AWireModeEnum>()
{
	static CEnumCommandMap<Agilent34980AWireModeEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980AWireMode1Wire, _T("WIRE1"), _T("")),
		new CEnumCommand(Agilent34980AWireMode2Wire, _T("WIRE2"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<Agilent34980ASequenceTriggerSourceEnum>* GetEnumSupportedModelMap<Agilent34980ASequenceTriggerSourceEnum>()
{
	static CEnumSupportedModelMap<Agilent34980ASequenceTriggerSourceEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<Agilent34980ASequenceTriggerSourceEnum>* GetEnumCommandMap<Agilent34980ASequenceTriggerSourceEnum>()
{
	static CEnumCommandMap<Agilent34980ASequenceTriggerSourceEnum> _enumCommandMap(
		new CEnumCommand(Agilent34980ASequenceTriggerSourceAlarm1, _T("ALAR1"), _T("")),
		new CEnumCommand(Agilent34980ASequenceTriggerSourceAlarm2, _T("ALAR2"), _T("")),
		new CEnumCommand(Agilent34980ASequenceTriggerSourceAlarm3, _T("ALAR3"), _T("")),
		new CEnumCommand(Agilent34980ASequenceTriggerSourceAlarm4, _T("ALAR4"), _T("")),
		new CEnumCommand(Agilent34980ASequenceTriggerSourceManual, _T("MAN"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmFunctionEnum>* GetEnumSupportedModelMap<IviDmmFunctionEnum>()
{
	static CEnumSupportedModelMap<IviDmmFunctionEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmFunctionEnum>* GetEnumCommandMap<IviDmmFunctionEnum>()
{
	static CEnumCommandMap<IviDmmFunctionEnum> _enumCommandMap(
		new CEnumCommand(IviDmmFunctionDCVolts, _T("VOLT"), _T("")),
		new CEnumCommand(IviDmmFunctionACVolts, _T("CURR:AC"), _T("")),
		new CEnumCommand(IviDmmFunctionDCCurrent, _T("CURR"), _T("")),
		new CEnumCommand(IviDmmFunctionACCurrent, _T("CURR:AC"), _T("")),
		new CEnumCommand(IviDmmFunction2WireRes, _T("RES"), _T("")),
		new CEnumCommand(IviDmmFunction4WireRes, _T("FRES"), _T("")),
		new CEnumCommand(IviDmmFunctionFreq, _T("FREQ"), _T("")),
		new CEnumCommand(IviDmmFunctionPeriod, _T("PER"), _T("")),
		new CEnumCommand(IviDmmFunctionACPlusDCVolts, _T(" "), _T("")),
		new CEnumCommand(IviDmmFunctionACPlusDCCurrent, _T(" "), _T("")),
		new CEnumCommand(IviDmmFunctionTemperature, _T("TEMP"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmApertureTimeUnitsEnum>* GetEnumSupportedModelMap<IviDmmApertureTimeUnitsEnum>()
{
	static CEnumSupportedModelMap<IviDmmApertureTimeUnitsEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmApertureTimeUnitsEnum>* GetEnumCommandMap<IviDmmApertureTimeUnitsEnum>()
{
	static CEnumCommandMap<IviDmmApertureTimeUnitsEnum> _enumCommandMap(
		new CEnumCommand(IviDmmApertureSeconds, _T(""), _T("")),
		new CEnumCommand(IviDmmAperturePowerLineCycles, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmAutoZeroEnum>* GetEnumSupportedModelMap<IviDmmAutoZeroEnum>()
{
	static CEnumSupportedModelMap<IviDmmAutoZeroEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmAutoZeroEnum>* GetEnumCommandMap<IviDmmAutoZeroEnum>()
{
	static CEnumCommandMap<IviDmmAutoZeroEnum> _enumCommandMap(
		new CEnumCommand(IviDmmAutoZeroOff, _T("OFF"), _T("")),
		new CEnumCommand(IviDmmAutoZeroOn, _T("ON"), _T("")),
		new CEnumCommand(IviDmmAutoZeroOnce, _T("ONCE"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmTransducerTypeEnum>* GetEnumSupportedModelMap<IviDmmTransducerTypeEnum>()
{
	static CEnumSupportedModelMap<IviDmmTransducerTypeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmTransducerTypeEnum>* GetEnumCommandMap<IviDmmTransducerTypeEnum>()
{
	static CEnumCommandMap<IviDmmTransducerTypeEnum> _enumCommandMap(
		new CEnumCommand(IviDmmTransducerTypeThermocouple, _T("TC"), _T("")),
		new CEnumCommand(IviDmmTransducerTypeThermistor, _T("THER"), _T("")),
		new CEnumCommand(IviDmmTransducerType2WireRtd, _T("RTD"), _T("")),
		new CEnumCommand(IviDmmTransducerType4WireRtd, _T("FRTD"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmThermocoupleTypeEnum>* GetEnumSupportedModelMap<IviDmmThermocoupleTypeEnum>()
{
	static CEnumSupportedModelMap<IviDmmThermocoupleTypeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmThermocoupleTypeEnum>* GetEnumCommandMap<IviDmmThermocoupleTypeEnum>()
{
	static CEnumCommandMap<IviDmmThermocoupleTypeEnum> _enumCommandMap(
		new CEnumCommand(IviDmmThermocoupleTypeB, _T("B"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeC, _T("C"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeD, _T("D"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeE, _T("E"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeG, _T("G"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeJ, _T("J"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeK, _T("K"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeN, _T("N"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeR, _T("R"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeS, _T("S"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeT, _T("T"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeU, _T("U"), _T("")),
		new CEnumCommand(IviDmmThermocoupleTypeV, _T("V"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmRefJunctionTypeEnum>* GetEnumSupportedModelMap<IviDmmRefJunctionTypeEnum>()
{
	static CEnumSupportedModelMap<IviDmmRefJunctionTypeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmRefJunctionTypeEnum>* GetEnumCommandMap<IviDmmRefJunctionTypeEnum>()
{
	static CEnumCommandMap<IviDmmRefJunctionTypeEnum> _enumCommandMap(
		new CEnumCommand(IviDmmRefJunctionTypeInternal, _T("INT"), _T("")),
		new CEnumCommand(IviDmmRefJunctionTypeFixed, _T("FIX"), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmTriggerSourceEnum>* GetEnumSupportedModelMap<IviDmmTriggerSourceEnum>()
{
	static CEnumSupportedModelMap<IviDmmTriggerSourceEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmTriggerSourceEnum>* GetEnumCommandMap<IviDmmTriggerSourceEnum>()
{
	static CEnumCommandMap<IviDmmTriggerSourceEnum> _enumCommandMap(
		new CEnumCommand(IviDmmTriggerSourceImmediate, _T("IMM"), _T("")),
		new CEnumCommand(IviDmmTriggerSourceExternal, _T("EXT"), _T("")),
		new CEnumCommand(IviDmmTriggerSourceSwTrigFunc, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceTTL0, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceTTL1, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceTTL2, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceTTL3, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceTTL4, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceTTL5, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceTTL6, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceTTL7, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceECL0, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceECL1, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourcePXIStar, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceRTSI0, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceRTSI1, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceRTSI2, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceRTSI3, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceRTSI4, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceRTSI5, _T(" "), _T("")),
		new CEnumCommand(IviDmmTriggerSourceRTSI6, _T(" "), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmTriggerSlopeEnum>* GetEnumSupportedModelMap<IviDmmTriggerSlopeEnum>()
{
	static CEnumSupportedModelMap<IviDmmTriggerSlopeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmTriggerSlopeEnum>* GetEnumCommandMap<IviDmmTriggerSlopeEnum>()
{
	static CEnumCommandMap<IviDmmTriggerSlopeEnum> _enumCommandMap(
		new CEnumCommand(IviDmmTriggerSlopePositive, _T(""), _T("")),
		new CEnumCommand(IviDmmTriggerSlopeNegative, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmSampleTriggerEnum>* GetEnumSupportedModelMap<IviDmmSampleTriggerEnum>()
{
	static CEnumSupportedModelMap<IviDmmSampleTriggerEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmSampleTriggerEnum>* GetEnumCommandMap<IviDmmSampleTriggerEnum>()
{
	static CEnumCommandMap<IviDmmSampleTriggerEnum> _enumCommandMap(
		new CEnumCommand(IviDmmSampleTriggerImmediate, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerExternal, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerSwTrigFunc, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerInterval, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerTTL0, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerTTL1, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerTTL2, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerTTL3, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerTTL4, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerTTL5, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerTTL6, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerTTL7, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerECL0, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerECL1, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerPXIStar, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerRTSI0, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerRTSI1, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerRTSI2, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerRTSI3, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerRTSI4, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerRTSI5, _T(""), _T("")),
		new CEnumCommand(IviDmmSampleTriggerRTSI6, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviDmmMeasCompleteDestEnum>* GetEnumSupportedModelMap<IviDmmMeasCompleteDestEnum>()
{
	static CEnumSupportedModelMap<IviDmmMeasCompleteDestEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviDmmMeasCompleteDestEnum>* GetEnumCommandMap<IviDmmMeasCompleteDestEnum>()
{
	static CEnumCommandMap<IviDmmMeasCompleteDestEnum> _enumCommandMap(
		new CEnumCommand(IviDmmMeasCompleteDestExternal, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestTTL0, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestTTL1, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestTTL2, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestTTL3, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestTTL4, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestTTL5, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestTTL6, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestTTL7, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestECL0, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestECL1, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestPXIStar, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestRTSI0, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestRTSI1, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestRTSI2, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestRTSI3, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestRTSI4, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestRTSI5, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestRTSI6, _T(""), _T("")),
		new CEnumCommand(IviDmmMeasCompleteDestNone, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<EventType>* GetEnumSupportedModelMap<EventType>()
{
	static CEnumSupportedModelMap<EventType> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<EventType>* GetEnumCommandMap<EventType>()
{
	static CEnumCommandMap<EventType> _enumCommandMap(
		new CEnumCommand(EVENT_IO_COMPLETION, _T(""), _T("")),
		new CEnumCommand(EVENT_SERVICE_REQ, _T(""), _T("")),
		new CEnumCommand(EVENT_CLEAR, _T(""), _T("")),
		new CEnumCommand(EVENT_GPIB_CIC, _T(""), _T("")),
		new CEnumCommand(EVENT_GPIB_TALK, _T(""), _T("")),
		new CEnumCommand(EVENT_GPIB_LISTEN, _T(""), _T("")),
		new CEnumCommand(EVENT_VXI_VME_SYSFAIL, _T(""), _T("")),
		new CEnumCommand(EVENT_VXI_VME_SYSRESET, _T(""), _T("")),
		new CEnumCommand(EVENT_VXI_SIGP, _T(""), _T("")),
		new CEnumCommand(EVENT_TCPIP_CONNECT, _T(""), _T("")),
		new CEnumCommand(EVENT_USB_INTR, _T(""), _T("")),
		new CEnumCommand(ALL_ENABLED_EVENTS, _T(""), _T("")),
		new CEnumCommand(EVENT_TRIG, _T(""), _T("")),
		new CEnumCommand(EVENT_EXCEPTION, _T(""), _T("")),
		new CEnumCommand(EVENT_VXI_VME_INTR, _T(""), _T("")),
		new CEnumCommand(CUSTOM_EVENT_TYPE, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IOProtocol>* GetEnumSupportedModelMap<IOProtocol>()
{
	static CEnumSupportedModelMap<IOProtocol> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IOProtocol>* GetEnumCommandMap<IOProtocol>()
{
	static CEnumCommandMap<IOProtocol> _enumCommandMap(
		new CEnumCommand(PROT_NORMAL, _T(""), _T("")),
		new CEnumCommand(PROT_FDC, _T(""), _T("")),
		new CEnumCommand(PROT_HS488, _T(""), _T("")),
		new CEnumCommand(PROT_4882_STRS, _T(""), _T("")),
		new CEnumCommand(PROT_USBTMC_VENDOR, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<FDCMode>* GetEnumSupportedModelMap<FDCMode>()
{
	static CEnumSupportedModelMap<FDCMode> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<FDCMode>* GetEnumCommandMap<FDCMode>()
{
	static CEnumCommandMap<FDCMode> _enumCommandMap(
		new CEnumCommand(FDC_NORMAL, _T(""), _T("")),
		new CEnumCommand(FDC_STREAM, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<EventMechanism>* GetEnumSupportedModelMap<EventMechanism>()
{
	static CEnumSupportedModelMap<EventMechanism> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<EventMechanism>* GetEnumCommandMap<EventMechanism>()
{
	static CEnumCommandMap<EventMechanism> _enumCommandMap(
		new CEnumCommand(EVENT_QUEUE, _T(""), _T("")),
		new CEnumCommand(EVENT_HNDLR, _T(""), _T("")),
		new CEnumCommand(EVENT_SUSPEND_HNDLR, _T(""), _T("")),
		new CEnumCommand(EVENT_ALL_MECH, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<TriggerLine>* GetEnumSupportedModelMap<TriggerLine>()
{
	static CEnumSupportedModelMap<TriggerLine> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<TriggerLine>* GetEnumCommandMap<TriggerLine>()
{
	static CEnumCommandMap<TriggerLine> _enumCommandMap(
		new CEnumCommand(TRIG_TTL0, _T(""), _T("")),
		new CEnumCommand(TRIG_TTL1, _T(""), _T("")),
		new CEnumCommand(TRIG_TTL2, _T(""), _T("")),
		new CEnumCommand(TRIG_TTL3, _T(""), _T("")),
		new CEnumCommand(TRIG_TTL4, _T(""), _T("")),
		new CEnumCommand(TRIG_TTL5, _T(""), _T("")),
		new CEnumCommand(TRIG_TTL6, _T(""), _T("")),
		new CEnumCommand(TRIG_TTL7, _T(""), _T("")),
		new CEnumCommand(TRIG_ECL0, _T(""), _T("")),
		new CEnumCommand(TRIG_ECL1, _T(""), _T("")),
		new CEnumCommand(TRIG_PANEL_IN, _T(""), _T("")),
		new CEnumCommand(TRIG_PANEL_OUT, _T(""), _T("")),
		new CEnumCommand(TRIG_ALL, _T(""), _T("")),
		new CEnumCommand(TRIG_SW, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<TriggerProtocol>* GetEnumSupportedModelMap<TriggerProtocol>()
{
	static CEnumSupportedModelMap<TriggerProtocol> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<TriggerProtocol>* GetEnumCommandMap<TriggerProtocol>()
{
	static CEnumCommandMap<TriggerProtocol> _enumCommandMap(
		new CEnumCommand(TRIG_PROT_DEFAULT, _T(""), _T("")),
		new CEnumCommand(TRIG_PROT_ON, _T(""), _T("")),
		new CEnumCommand(TRIG_PROT_OFF, _T(""), _T("")),
		new CEnumCommand(TRIG_PROT_SYNC, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<BufferMask>* GetEnumSupportedModelMap<BufferMask>()
{
	static CEnumSupportedModelMap<BufferMask> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<BufferMask>* GetEnumCommandMap<BufferMask>()
{
	static CEnumCommandMap<BufferMask> _enumCommandMap(
		new CEnumCommand(IO_IN_BUF, _T(""), _T("")),
		new CEnumCommand(IO_OUT_BUF, _T(""), _T("")),
		new CEnumCommand(IO_IN_AND_OUT_BUFS, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<AccessMode>* GetEnumSupportedModelMap<AccessMode>()
{
	static CEnumSupportedModelMap<AccessMode> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<AccessMode>* GetEnumCommandMap<AccessMode>()
{
	static CEnumCommandMap<AccessMode> _enumCommandMap(
		new CEnumCommand(NO_LOCK, _T(""), _T("")),
		new CEnumCommand(EXCLUSIVE_LOCK, _T(""), _T("")),
		new CEnumCommand(SHARED_LOCK, _T(""), _T("")),
		new CEnumCommand(LOAD_CONFIG, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<SerialParity>* GetEnumSupportedModelMap<SerialParity>()
{
	static CEnumSupportedModelMap<SerialParity> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<SerialParity>* GetEnumCommandMap<SerialParity>()
{
	static CEnumCommandMap<SerialParity> _enumCommandMap(
		new CEnumCommand(ASRL_PAR_NONE, _T(""), _T("")),
		new CEnumCommand(ASRL_PAR_ODD, _T(""), _T("")),
		new CEnumCommand(ASRL_PAR_EVEN, _T(""), _T("")),
		new CEnumCommand(ASRL_PAR_MARK, _T(""), _T("")),
		new CEnumCommand(ASRL_PAR_SPACE, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<SerialStopBits>* GetEnumSupportedModelMap<SerialStopBits>()
{
	static CEnumSupportedModelMap<SerialStopBits> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<SerialStopBits>* GetEnumCommandMap<SerialStopBits>()
{
	static CEnumCommandMap<SerialStopBits> _enumCommandMap(
		new CEnumCommand(ASRL_STOP_ONE, _T(""), _T("")),
		new CEnumCommand(ASRL_STOP_ONE5, _T(""), _T("")),
		new CEnumCommand(ASRL_STOP_TWO, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<SerialFlowControl>* GetEnumSupportedModelMap<SerialFlowControl>()
{
	static CEnumSupportedModelMap<SerialFlowControl> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<SerialFlowControl>* GetEnumCommandMap<SerialFlowControl>()
{
	static CEnumCommandMap<SerialFlowControl> _enumCommandMap(
		new CEnumCommand(ASRL_FLOW_NONE, _T(""), _T("")),
		new CEnumCommand(ASRL_FLOW_XON_XOFF, _T(""), _T("")),
		new CEnumCommand(ASRL_FLOW_RTS_CTS, _T(""), _T("")),
		new CEnumCommand(ASRL_FLOW_RTS_CTS_AND_XON_XOFF, _T(""), _T("")),
		new CEnumCommand(ASRL_FLOW_DTR_DSR, _T(""), _T("")),
		new CEnumCommand(ASRL_FLOW_DTR_DSR_AND_XON_XOFF, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<SerialEndConst>* GetEnumSupportedModelMap<SerialEndConst>()
{
	static CEnumSupportedModelMap<SerialEndConst> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<SerialEndConst>* GetEnumCommandMap<SerialEndConst>()
{
	static CEnumCommandMap<SerialEndConst> _enumCommandMap(
		new CEnumCommand(ASRL_END_NONE, _T(""), _T("")),
		new CEnumCommand(ASRL_END_LAST_BIT, _T(""), _T("")),
		new CEnumCommand(ASRL_END_TERMCHAR, _T(""), _T("")),
		new CEnumCommand(ASRL_END_BREAK, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<LineState>* GetEnumSupportedModelMap<LineState>()
{
	static CEnumSupportedModelMap<LineState> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<LineState>* GetEnumCommandMap<LineState>()
{
	static CEnumCommandMap<LineState> _enumCommandMap(
		new CEnumCommand(STATE_UNASSERTED, _T(""), _T("")),
		new CEnumCommand(STATE_ASSERTED, _T(""), _T("")),
		new CEnumCommand(STATE_UNKNOWN, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<VXIMemoryAccessPrivilege>* GetEnumSupportedModelMap<VXIMemoryAccessPrivilege>()
{
	static CEnumSupportedModelMap<VXIMemoryAccessPrivilege> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<VXIMemoryAccessPrivilege>* GetEnumCommandMap<VXIMemoryAccessPrivilege>()
{
	static CEnumCommandMap<VXIMemoryAccessPrivilege> _enumCommandMap(
		new CEnumCommand(DATA_PRIV, _T(""), _T("")),
		new CEnumCommand(DATA_NPRIV, _T(""), _T("")),
		new CEnumCommand(PROG_PRIV, _T(""), _T("")),
		new CEnumCommand(PROG_NPRIV, _T(""), _T("")),
		new CEnumCommand(BLCK_PRIV, _T(""), _T("")),
		new CEnumCommand(BLCK_NPRIV, _T(""), _T("")),
		new CEnumCommand(D64_PRIV, _T(""), _T("")),
		new CEnumCommand(D64_NPRIV, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<DataWidth>* GetEnumSupportedModelMap<DataWidth>()
{
	static CEnumSupportedModelMap<DataWidth> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<DataWidth>* GetEnumCommandMap<DataWidth>()
{
	static CEnumCommandMap<DataWidth> _enumCommandMap(
		new CEnumCommand(WIDTH_8, _T(""), _T("")),
		new CEnumCommand(WIDTH_16, _T(""), _T("")),
		new CEnumCommand(WIDTH_32, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<RENControlConst>* GetEnumSupportedModelMap<RENControlConst>()
{
	static CEnumSupportedModelMap<RENControlConst> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<RENControlConst>* GetEnumCommandMap<RENControlConst>()
{
	static CEnumCommandMap<RENControlConst> _enumCommandMap(
		new CEnumCommand(GPIB_REN_DEASSERT, _T(""), _T("")),
		new CEnumCommand(GPIB_REN_ASSERT, _T(""), _T("")),
		new CEnumCommand(GPIB_REN_GTL_AND_DEASSERT, _T(""), _T("")),
		new CEnumCommand(GPIB_REN_ASSERT_AND_ADDRESS, _T(""), _T("")),
		new CEnumCommand(GPIB_REN_LLO, _T(""), _T("")),
		new CEnumCommand(GPIB_REN_ADDRESS_AND_LLO, _T(""), _T("")),
		new CEnumCommand(GPIB_REN_GTL, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<ATNControlConst>* GetEnumSupportedModelMap<ATNControlConst>()
{
	static CEnumSupportedModelMap<ATNControlConst> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<ATNControlConst>* GetEnumCommandMap<ATNControlConst>()
{
	static CEnumCommandMap<ATNControlConst> _enumCommandMap(
		new CEnumCommand(GPIB_ATN_DEASSERT, _T(""), _T("")),
		new CEnumCommand(GPIB_ATN_ASSERT, _T(""), _T("")),
		new CEnumCommand(GPIB_ATN_DEASSERT_HANDSHAKE, _T(""), _T("")),
		new CEnumCommand(GPIB_ATN_ASSERT_IMMEDIATE, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<GPIBAddressState>* GetEnumSupportedModelMap<GPIBAddressState>()
{
	static CEnumSupportedModelMap<GPIBAddressState> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<GPIBAddressState>* GetEnumCommandMap<GPIBAddressState>()
{
	static CEnumCommandMap<GPIBAddressState> _enumCommandMap(
		new CEnumCommand(GPIB_UNADDRESSED, _T(""), _T("")),
		new CEnumCommand(GPIB_TALKER, _T(""), _T("")),
		new CEnumCommand(GPIB_LISTENER, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<VXICommandQuery>* GetEnumSupportedModelMap<VXICommandQuery>()
{
	static CEnumSupportedModelMap<VXICommandQuery> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<VXICommandQuery>* GetEnumCommandMap<VXICommandQuery>()
{
	static CEnumCommandMap<VXICommandQuery> _enumCommandMap(
		new CEnumCommand(VXI_RESP16, _T(""), _T("")),
		new CEnumCommand(VXI_RESP32, _T(""), _T("")),
		new CEnumCommand(VXI_CMD16, _T(""), _T("")),
		new CEnumCommand(VXI_CMD16_RESP16, _T(""), _T("")),
		new CEnumCommand(VXI_CMD32, _T(""), _T("")),
		new CEnumCommand(VXI_CMD32_RESP16, _T(""), _T("")),
		new CEnumCommand(VXI_CMD32_RESP32, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<AssertInterruptConst>* GetEnumSupportedModelMap<AssertInterruptConst>()
{
	static CEnumSupportedModelMap<AssertInterruptConst> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<AssertInterruptConst>* GetEnumCommandMap<AssertInterruptConst>()
{
	static CEnumCommandMap<AssertInterruptConst> _enumCommandMap(
		new CEnumCommand(ASSERT_USE_ASSIGNED, _T(""), _T("")),
		new CEnumCommand(ASSERT_IRQ1, _T(""), _T("")),
		new CEnumCommand(ASSERT_IRQ2, _T(""), _T("")),
		new CEnumCommand(ASSERT_IRQ3, _T(""), _T("")),
		new CEnumCommand(ASSERT_IRQ4, _T(""), _T("")),
		new CEnumCommand(ASSERT_IRQ5, _T(""), _T("")),
		new CEnumCommand(ASSERT_IRQ6, _T(""), _T("")),
		new CEnumCommand(ASSERT_IRQ7, _T(""), _T("")),
		new CEnumCommand(ASSERT_SIGNAL, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<AssertUtilityConst>* GetEnumSupportedModelMap<AssertUtilityConst>()
{
	static CEnumSupportedModelMap<AssertUtilityConst> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<AssertUtilityConst>* GetEnumCommandMap<AssertUtilityConst>()
{
	static CEnumCommandMap<AssertUtilityConst> _enumCommandMap(
		new CEnumCommand(ASSERT_SYSRESET, _T(""), _T("")),
		new CEnumCommand(ASSERT_SYSFAIL, _T(""), _T("")),
		new CEnumCommand(DEASSERT_SYSFAIL, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<VXIDevClass>* GetEnumSupportedModelMap<VXIDevClass>()
{
	static CEnumSupportedModelMap<VXIDevClass> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<VXIDevClass>* GetEnumCommandMap<VXIDevClass>()
{
	static CEnumCommandMap<VXIDevClass> _enumCommandMap(
		new CEnumCommand(VXI_CLASS_MEMORY, _T(""), _T("")),
		new CEnumCommand(VXI_CLASS_EXTENDED, _T(""), _T("")),
		new CEnumCommand(VXI_CLASS_MESSAGE, _T(""), _T("")),
		new CEnumCommand(VXI_CLASS_REGISTER, _T(""), _T("")),
		new CEnumCommand(VXI_CLASS_OTHER, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IEEEASCIIType>* GetEnumSupportedModelMap<IEEEASCIIType>()
{
	static CEnumSupportedModelMap<IEEEASCIIType> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IEEEASCIIType>* GetEnumCommandMap<IEEEASCIIType>()
{
	static CEnumCommandMap<IEEEASCIIType> _enumCommandMap(
		new CEnumCommand(ASCIIType_I2, _T(""), _T("")),
		new CEnumCommand(ASCIIType_I4, _T(""), _T("")),
		new CEnumCommand(ASCIIType_R4, _T(""), _T("")),
		new CEnumCommand(ASCIIType_R8, _T(""), _T("")),
		new CEnumCommand(ASCIIType_BSTR, _T(""), _T("")),
		new CEnumCommand(ASCIIType_Any, _T(""), _T("")),
		new CEnumCommand(ASCIIType_UI1, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IEEEBinaryType>* GetEnumSupportedModelMap<IEEEBinaryType>()
{
	static CEnumSupportedModelMap<IEEEBinaryType> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IEEEBinaryType>* GetEnumCommandMap<IEEEBinaryType>()
{
	static CEnumCommandMap<IEEEBinaryType> _enumCommandMap(
		new CEnumCommand(BinaryType_I2, _T(""), _T("")),
		new CEnumCommand(BinaryType_I4, _T(""), _T("")),
		new CEnumCommand(BinaryType_R4, _T(""), _T("")),
		new CEnumCommand(BinaryType_R8, _T(""), _T("")),
		new CEnumCommand(BinaryType_UI1, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<ConflictHandlerType>* GetEnumSupportedModelMap<ConflictHandlerType>()
{
	static CEnumSupportedModelMap<ConflictHandlerType> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<ConflictHandlerType>* GetEnumCommandMap<ConflictHandlerType>()
{
	static CEnumCommandMap<ConflictHandlerType> _enumCommandMap(
		new CEnumCommand(NotChosen, _T(""), _T("")),
		new CEnumCommand(ChosenByResourceManager, _T(""), _T("")),
		new CEnumCommand(ChosenByUser, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviSwtchPathCapabilityEnum>* GetEnumSupportedModelMap<IviSwtchPathCapabilityEnum>()
{
	static CEnumSupportedModelMap<IviSwtchPathCapabilityEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviSwtchPathCapabilityEnum>* GetEnumCommandMap<IviSwtchPathCapabilityEnum>()
{
	static CEnumCommandMap<IviSwtchPathCapabilityEnum> _enumCommandMap(
		new CEnumCommand(IviSwtchPathAvailable, _T(""), _T("")),
		new CEnumCommand(IviSwtchPathExists, _T(""), _T("")),
		new CEnumCommand(IviSwtchPathUnsupported, _T(""), _T("")),
		new CEnumCommand(IviSwtchPathRsrcInUse, _T(""), _T("")),
		new CEnumCommand(IviSwtchPathSourceConflict, _T(""), _T("")),
		new CEnumCommand(IviSwtchPathChannelNotAvailable, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviSwtchScanModeEnum>* GetEnumSupportedModelMap<IviSwtchScanModeEnum>()
{
	static CEnumSupportedModelMap<IviSwtchScanModeEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviSwtchScanModeEnum>* GetEnumCommandMap<IviSwtchScanModeEnum>()
{
	static CEnumCommandMap<IviSwtchScanModeEnum> _enumCommandMap(
		new CEnumCommand(IviSwtchScanModeNone, _T(""), _T("")),
		new CEnumCommand(IviSwtchScanModeBreakBeforeMake, _T(""), _T("")),
		new CEnumCommand(IviSwtchScanModeBreakAfterMake, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviSwtchTriggerInputEnum>* GetEnumSupportedModelMap<IviSwtchTriggerInputEnum>()
{
	static CEnumSupportedModelMap<IviSwtchTriggerInputEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviSwtchTriggerInputEnum>* GetEnumCommandMap<IviSwtchTriggerInputEnum>()
{
	static CEnumCommandMap<IviSwtchTriggerInputEnum> _enumCommandMap(
		new CEnumCommand(IviSwtchTriggerInputImmediate, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputExternal, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputSwTrigFunc, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputTTL0, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputTTL1, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputTTL2, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputTTL3, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputTTL4, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputTTL5, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputTTL6, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputTTL7, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputECL0, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputECL1, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputPXIStar, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputRTSI0, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputRTSI1, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputRTSI2, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputRTSI3, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputRTSI4, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputRTSI5, _T(""), _T("")),
		new CEnumCommand(IviSwtchTriggerInputRTSI6, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}

template <>
const CEnumSupportedModelMap<IviSwtchAdvancedOutputEnum>* GetEnumSupportedModelMap<IviSwtchAdvancedOutputEnum>()
{
	static CEnumSupportedModelMap<IviSwtchAdvancedOutputEnum> _enumSupportedModelMap(
		NULL);

	return &_enumSupportedModelMap;
}

template <>
const CEnumCommandMap<IviSwtchAdvancedOutputEnum>* GetEnumCommandMap<IviSwtchAdvancedOutputEnum>()
{
	static CEnumCommandMap<IviSwtchAdvancedOutputEnum> _enumCommandMap(
		new CEnumCommand(IviSwtchAdvancedOutputNone, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputExternal, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputGPIBSRQ, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputTTL0, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputTTL1, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputTTL2, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputTTL3, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputTTL4, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputTTL5, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputTTL6, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputTTL7, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputECL0, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputECL1, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputPXIStar, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputRTSI0, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputRTSI1, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputRTSI2, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputRTSI3, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputRTSI4, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputRTSI5, _T(""), _T("")),
		new CEnumCommand(IviSwtchAdvancedOutputRTSI6, _T(""), _T("")),
		NULL);

	return &_enumCommandMap;
}



///////////////////////////////////////////////////////////////////////////////
//
//	Instrument I/O support
//

CString CDriver<Agilent34980A, CVisaComIOProvider>::GetVisaDllFileName()
{
	return _T("visa32.dll");
}


///////////////////////////////////////////////////////////////////////////////
//
//	Instrument personality support
//

const CString& CPersonalityHost<Agilent34980A, CVisaComIOProvider>::GetPersonalityHostID()
{
	static const CString _hostID(_T("Agilent34980A"));

	return _hostID;
}


///////////////////////////////////////////////////////////////////////////////
//
//	Event server support
//

CEventServerSource* CDriver<Agilent34980A, CVisaComIOProvider>::CreateSource()
{
	return new CEventServerSourceAllLevels(this);
}

CEventServerSink* CDriver<Agilent34980A, CVisaComIOProvider>::CreateSink()
{
	return new CEventServerNoSink(this);
}

const _EVENTSERVER_LOCATION_INFO* CDriver<Agilent34980A, CVisaComIOProvider>::GetLocationInfo() const
{
	static const _EVENTSERVER_LOCATION_INFO _locationInfo = 
	{ 
		L"Agilent34980A",		
		L"Agilent34980A"		
	};

	return &_locationInfo;
}

///////////////////////////////////////////////////////////////////////////////
//
//	State caching support
//

const CComparePolicyManagerBase* GetComparePolicyManager(const CString& strPath)
{
	static const CComparePolicyManagerMap _comparePolicyManagerMap(
		NULL);

	return _comparePolicyManagerMap.LookupComparePolicyManager(strPath);
}

///////////////////////////////////////////////////////////////////////////////
//
//	Coercion support
//

long GetCoercionLogSize()
{
	return 1000;
}


///////////////////////////////////////////////////////////////////////////////
//
//	COM rich error support
//

STDMETHODIMP Agilent34980A::InterfaceSupportsErrorInfo(REFIID riid)
{
	static const IID* arr[] = 
	{
		&__uuidof(IAgilent34980A),
		&__uuidof(IAgilent34980APersonality),
		&__uuidof(IIviDmmAC),
		&__uuidof(IIviDmmAdvanced),
		&__uuidof(IIviDmmFrequency),
		&__uuidof(IIviDmmMeasurement),
		&__uuidof(IIviDmmRTD),
		&__uuidof(IIviDmmThermocouple),
		&__uuidof(IIviDmmThermistor),
		&__uuidof(IIviDmmTemperature),
		&__uuidof(IIviDmmMultiPoint),
		&__uuidof(IIviDmmTrigger),
		&__uuidof(IIviDmm),
		&__uuidof(IIviDriver),
		&__uuidof(IIviDriverOperation),
		&__uuidof(IIviDriverIdentity),
		&__uuidof(IIviComponentIdentity),
		&__uuidof(IIviDriverUtility),
		&__uuidof(IAgilent34980AAlarm),
		&__uuidof(IAgilent34980AACVoltage),
		&__uuidof(IAgilent34980AACCurrent),
		&__uuidof(IAgilent34980ACalibration),
		&__uuidof(IAgilent34980ACurrent),
		&__uuidof(IAgilent34980ADCCurrent),
		&__uuidof(IAgilent34980ADCVoltage),
		&__uuidof(IAgilent34980ADiagnostic),
		&__uuidof(IAgilent34980ADisplay),
		&__uuidof(IAgilent34980AFrequency),
		&__uuidof(IAgilent34980AFResistance),
		&__uuidof(IAgilent34980AMeasurement),
		&__uuidof(IAgilent34980AMemory),
		&__uuidof(IAgilent34980APeriod),
		&__uuidof(IAgilent34980AResistance),
		&__uuidof(IAgilent34980AScale),
		&__uuidof(IAgilent34980ARoute),
		&__uuidof(IAgilent34980AScan),
		&__uuidof(IAgilent34980AStatistics),
		&__uuidof(IAgilent34980AStatus),
		&__uuidof(IAgilent34980ASystem),
		&__uuidof(IAgilent34980ATemperature),
		&__uuidof(IAgilent34980AVoltage),
		&__uuidof(IAgilent34980AFRTD),
		&__uuidof(IAgilent34980ADataFormat),
		&__uuidof(IAgilent34980ARTD),
		&__uuidof(IAgilent34980AThermistor),
		&__uuidof(IAgilent34980AThermocouple),
		&__uuidof(IAgilent34980ATrigger),
		&__uuidof(IIviSwtch),
		&__uuidof(IIviSwtchChannels),
		&__uuidof(IIviSwtchPath),
		&__uuidof(IIviSwtchScan),
		&__uuidof(IAgilent34980ADMM),
		&__uuidof(IAgilent34980ADAC),
		&__uuidof(IAgilent34980AAlarm2),
		&__uuidof(IAgilent34980A2),
		&__uuidof(IAgilent34980ARoute2),
		&__uuidof(IAgilent34980AStatus2),
		&__uuidof(IProvideClassInfo),
		&__uuidof(IProvideClassInfo2)
	};

	for (int i=0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		if (InlineIsEqualGUID(*arr[i],riid))
			return S_OK;
	}
	return S_FALSE;
}

///////////////////////////////////////////////////////////////////////////////
//
//	Error map support
//

const CString& GetHelpFileName()
{
	static CString _strFileName(_T("Agilent34980A.chm"));

	return _strFileName;
}


UINT GetDriverErrorResourceId(UINT uNtlResid)
{
	UINT uResId = 0;

	switch (uNtlResid)
	{
			case NTL_IDS_PERSONALITY_NOT_ACTIVE: 
				uResId = IDS_E_AGILENT34980A_PERSONALITY_NOT_ACTIVE; 
				break;
			case NTL_IDS_PERSONALITY_NOT_INSTALLED: 
				uResId = IDS_E_AGILENT34980A_PERSONALITY_NOT_INSTALLED; 
				break;
			case NTL_IDS_PERSONALITY_NOT_LICENSED: 
				uResId = IDS_E_AGILENT34980A_PERSONALITY_NOT_LICENSED; 
				break;
			case NTL_IDS_IO_GENERAL: 
				uResId = IDS_E_AGILENT34980A_IO_GENERAL; 
				break;
			case NTL_IDS_IO_TIMEOUT: 
				uResId = IDS_E_AGILENT34980A_IO_TIMEOUT; 
				break;
			case NTL_IDS_MODEL_NOT_SUPPORTED: 
				uResId = IDS_E_AGILENT34980A_MODEL_NOT_SUPPORTED; 
				break;
			case NTL_IDS_WRAPPED_DRIVER_ERROR: 
				uResId = IDS_E_AGILENT34980A_WRAPPED_DRIVER_ERROR; 
				break;

	}

	return uResId;
}

const CErrorMap* GetDriverErrorMap()
{
	static const CErrorMap _errorMap(
		new CDriverErrorInfo(IDS_E_AGILENT34980A_UNEXPECTED, E_AGILENT34980A_UNEXPECTED, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_PERSONALITY_NOT_ACTIVE, E_AGILENT34980A_PERSONALITY_NOT_ACTIVE, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_PERSONALITY_NOT_INSTALLED, E_AGILENT34980A_PERSONALITY_NOT_INSTALLED, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_PERSONALITY_NOT_LICENSED, E_AGILENT34980A_PERSONALITY_NOT_LICENSED, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_IO_GENERAL, E_AGILENT34980A_IO_GENERAL, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_IO_TIMEOUT, E_AGILENT34980A_IO_TIMEOUT, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_MODEL_NOT_SUPPORTED, E_AGILENT34980A_MODEL_NOT_SUPPORTED, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_VALUE_OUT_OF_RANGE, E_AGILENT34980A_VALUE_OUT_OF_RANGE, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_WRAPPED_DRIVER_ERROR, E_AGILENT34980A_WRAPPED_DRIVER_ERROR, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_LOCATIONS_BUSY, E_AGILENT34980A_LOCATIONS_BUSY, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_MULTIPLE_CHANNELS_IN_GET, E_AGILENT34980A_MULTIPLE_CHANNELS_IN_GET, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_MISSING_DMM_OPTION, E_AGILENT34980A_MISSING_DMM_OPTION, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_BAD_SIMULATION_OPTION, E_AGILENT34980A_BAD_SIMULATION_OPTION, 0),
		new CDriverErrorInfo(IDS_E_AGILENT34980A_MISSING_SIMULATION_OPTION, E_AGILENT34980A_MISSING_SIMULATION_OPTION, 0),
		new CDriverErrorInfo(IDS_S_IVI_SUCCESS, S_IVI_SUCCESS, 0),
		new CDriverErrorInfo(IDS_S_IVI_NSUP_ID_QUERY, S_IVI_NSUP_ID_QUERY, 0),
		new CDriverErrorInfo(IDS_S_IVI_NSUP_RESET, S_IVI_NSUP_RESET, 0),
		new CDriverErrorInfo(IDS_S_IVI_NSUP_SELF_TEST, S_IVI_NSUP_SELF_TEST, 0),
		new CDriverErrorInfo(IDS_S_IVI_NSUP_ERROR_QUERY, S_IVI_NSUP_ERROR_QUERY, 0),
		new CDriverErrorInfo(IDS_S_IVI_NSUP_REV_QUERY, S_IVI_NSUP_REV_QUERY, 0),
		new CDriverErrorInfo(IDS_E_IVI_CANNOT_RECOVER, E_IVI_CANNOT_RECOVER, 0),
		new CDriverErrorInfo(IDS_E_IVI_INSTRUMENT_STATUS, E_IVI_INSTRUMENT_STATUS, 0),
		new CDriverErrorInfo(IDS_E_IVI_CANNOT_OPEN_FILE, E_IVI_CANNOT_OPEN_FILE, 0),
		new CDriverErrorInfo(IDS_E_IVI_READING_FILE, E_IVI_READING_FILE, 0),
		new CDriverErrorInfo(IDS_E_IVI_WRITING_FILE, E_IVI_WRITING_FILE, 0),
		new CDriverErrorInfo(IDS_E_IVI_INVALID_PATHNAME, E_IVI_INVALID_PATHNAME, 0),
		new CDriverErrorInfo(IDS_E_IVI_INVALID_VALUE, E_IVI_INVALID_VALUE, 0),
		new CDriverErrorInfo(IDS_E_IVI_METHOD_NOT_SUPPORTED, E_IVI_METHOD_NOT_SUPPORTED, 0),
		new CDriverErrorInfo(IDS_E_IVI_PROPERTY_NOT_SUPPORTED, E_IVI_PROPERTY_NOT_SUPPORTED, 0),
		new CDriverErrorInfo(IDS_E_IVI_VALUE_NOT_SUPPORTED, E_IVI_VALUE_NOT_SUPPORTED, 0),
		new CDriverErrorInfo(IDS_E_IVI_NOT_INITIALIZED, E_IVI_NOT_INITIALIZED, 0),
		new CDriverErrorInfo(IDS_E_IVI_UNKNOWN_CHANNEL_NAME, E_IVI_UNKNOWN_CHANNEL_NAME, 0),
		new CDriverErrorInfo(IDS_E_IVI_TOO_MANY_OPEN_FILES, E_IVI_TOO_MANY_OPEN_FILES, 0),
		new CDriverErrorInfo(IDS_E_IVI_CHANNEL_NAME_REQUIRED, E_IVI_CHANNEL_NAME_REQUIRED, 0),
		new CDriverErrorInfo(IDS_E_IVI_MISSING_OPTION_NAME, E_IVI_MISSING_OPTION_NAME, 0),
		new CDriverErrorInfo(IDS_E_IVI_MISSING_OPTION_VALUE, E_IVI_MISSING_OPTION_VALUE, 0),
		new CDriverErrorInfo(IDS_E_IVI_BAD_OPTION_NAME, E_IVI_BAD_OPTION_NAME, 0),
		new CDriverErrorInfo(IDS_E_IVI_BAD_OPTION_VALUE, E_IVI_BAD_OPTION_VALUE, 0),
		new CDriverErrorInfo(IDS_E_IVI_OUT_OF_MEMORY, E_IVI_OUT_OF_MEMORY, 0),
		new CDriverErrorInfo(IDS_E_IVI_OPERATION_PENDING, E_IVI_OPERATION_PENDING, 0),
		new CDriverErrorInfo(IDS_E_IVI_NULL_POINTER, E_IVI_NULL_POINTER, 0),
		new CDriverErrorInfo(IDS_E_IVI_UNEXPECTED_RESPONSE, E_IVI_UNEXPECTED_RESPONSE, 0),
		new CDriverErrorInfo(IDS_E_IVI_FILE_NOT_FOUND, E_IVI_FILE_NOT_FOUND, 0),
		new CDriverErrorInfo(IDS_E_IVI_INVALID_FILE_FORMAT, E_IVI_INVALID_FILE_FORMAT, 0),
		new CDriverErrorInfo(IDS_E_IVI_STATUS_NOT_AVAILABLE, E_IVI_STATUS_NOT_AVAILABLE, 0),
		new CDriverErrorInfo(IDS_E_IVI_ID_QUERY_FAILED, E_IVI_ID_QUERY_FAILED, 0),
		new CDriverErrorInfo(IDS_E_IVI_RESET_FAILED, E_IVI_RESET_FAILED, 0),
		new CDriverErrorInfo(IDS_E_IVI_RESOURCE_UNKNOWN, E_IVI_RESOURCE_UNKNOWN, 0),
		new CDriverErrorInfo(IDS_E_IVI_ALREADY_INITIALIZED, E_IVI_ALREADY_INITIALIZED, 0),
		new CDriverErrorInfo(IDS_E_IVI_CANNOT_CHANGE_SIMULATION_STATE, E_IVI_CANNOT_CHANGE_SIMULATION_STATE, 0),
		new CDriverErrorInfo(IDS_E_IVI_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, E_IVI_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, 0),
		new CDriverErrorInfo(IDS_E_IVI_INVALID_RANGE_IN_SELECTOR, E_IVI_INVALID_RANGE_IN_SELECTOR, 0),
		new CDriverErrorInfo(IDS_E_IVI_UNKNOWN_NAME_IN_SELECTOR, E_IVI_UNKNOWN_NAME_IN_SELECTOR, 0),
		new CDriverErrorInfo(IDS_E_IVI_BADLY_FORMED_SELECTOR, E_IVI_BADLY_FORMED_SELECTOR, 0),
		new CDriverErrorInfo(IDS_E_IVI_UNKNOWN_PHYSICAL_IDENTIFIER, E_IVI_UNKNOWN_PHYSICAL_IDENTIFIER, 0),
		new CDriverErrorInfo(IDS_E_IVIDMM_MAX_TIME_EXCEEDED, E_IVIDMM_MAX_TIME_EXCEEDED, 0),
		new CDriverErrorInfo(IDS_E_IVIDMM_TRIGGER_NOT_SOFTWARE, E_IVIDMM_TRIGGER_NOT_SOFTWARE, 0),
		new CDriverErrorInfo(IDS_S_IVIDMM_OVER_RANGE, S_IVIDMM_OVER_RANGE, 0),
		new CDriverErrorInfo(IDS_S_IVISWTCH_PATH_REMAINS, S_IVISWTCH_PATH_REMAINS, 0),
		new CDriverErrorInfo(IDS_S_IVISWTCH_IMPLICIT_CONNECTION_EXISTS, S_IVISWTCH_IMPLICIT_CONNECTION_EXISTS, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_TRIGGER_NOT_SOFTWARE, E_IVISWTCH_TRIGGER_NOT_SOFTWARE, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_INVALID_SWITCH_PATH, E_IVISWTCH_INVALID_SWITCH_PATH, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_INVALID_SCAN_LIST, E_IVISWTCH_INVALID_SCAN_LIST, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_RSRC_IN_USE, E_IVISWTCH_RSRC_IN_USE, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_EMPTY_SCAN_LIST, E_IVISWTCH_EMPTY_SCAN_LIST, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_EMPTY_SWITCH_PATH, E_IVISWTCH_EMPTY_SWITCH_PATH, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_SCAN_IN_PROGRESS, E_IVISWTCH_SCAN_IN_PROGRESS, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_NO_SCAN_IN_PROGRESS, E_IVISWTCH_NO_SCAN_IN_PROGRESS, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_NO_SUCH_PATH, E_IVISWTCH_NO_SUCH_PATH, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_IS_CONFIGURATION_CHANNEL, E_IVISWTCH_IS_CONFIGURATION_CHANNEL, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_NOT_A_CONFIGURATION_CHANNEL, E_IVISWTCH_NOT_A_CONFIGURATION_CHANNEL, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_ATTEMPT_TO_CONNECT_SOURCES, E_IVISWTCH_ATTEMPT_TO_CONNECT_SOURCES, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_EXPLICIT_CONNECTION_EXISTS, E_IVISWTCH_EXPLICIT_CONNECTION_EXISTS, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_LEG_MISSING_FIRST_CHANNEL, E_IVISWTCH_LEG_MISSING_FIRST_CHANNEL, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_LEG_MISSING_SECOND_CHANNEL, E_IVISWTCH_LEG_MISSING_SECOND_CHANNEL, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_CHANNEL_DUPLICATED_IN_LEG, E_IVISWTCH_CHANNEL_DUPLICATED_IN_LEG, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_CHANNEL_DUPLICATED_IN_PATH, E_IVISWTCH_CHANNEL_DUPLICATED_IN_PATH, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_PATH_NOT_FOUND, E_IVISWTCH_PATH_NOT_FOUND, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_DISCONTINUOUS_PATH, E_IVISWTCH_DISCONTINUOUS_PATH, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_CANNOT_CONNECT_DIRECTLY, E_IVISWTCH_CANNOT_CONNECT_DIRECTLY, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_CHANNELS_ALREADY_CONNECTED, E_IVISWTCH_CHANNELS_ALREADY_CONNECTED, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_CANNOT_CONNECT_TO_ITSELF, E_IVISWTCH_CANNOT_CONNECT_TO_ITSELF, 0),
		new CDriverErrorInfo(IDS_E_IVISWTCH_MAX_TIME_EXCEEDED, E_IVISWTCH_MAX_TIME_EXCEEDED, 0),
		NULL);

	return &_errorMap;
}


