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

#ifndef __FORWARDINGSHIMS_H__
#define __FORWARDINGSHIMS_H__

class Agilent34980A;
class Agilent34980AChannel;


typedef CPersonalityHost<Agilent34980A, CVisaComIOProvider> DriverBase;

template <typename T>
const CComparePolicyManager<T>* CComparePolicyManager<T>::GetDefaultPolicyManager()
{
	static const CComparePolicyManager<T> _comparePolicyManager(
		new CSimpleComparePolicy<T>(14),
		NULL);

	return &_comparePolicyManager;
}

HRESULT IAgilent34980A_get_Alarm(Agilent34980A* pT, IAgilent34980AAlarm** val);
HRESULT IAgilent34980A_get_Calibration(Agilent34980A* pT, IAgilent34980ACalibration** val);
HRESULT IAgilent34980A_get_Current(Agilent34980A* pT, IAgilent34980ACurrent** val);
HRESULT IAgilent34980A_get_Diagnostic(Agilent34980A* pT, IAgilent34980ADiagnostic** val);
HRESULT IAgilent34980A_get_Display(Agilent34980A* pT, IAgilent34980ADisplay** val);
HRESULT IAgilent34980A_get_Frequency(Agilent34980A* pT, IAgilent34980AFrequency** val);
HRESULT IAgilent34980A_get_FResistance(Agilent34980A* pT, IAgilent34980AFResistance** val);
HRESULT IAgilent34980A_get_Measurement(Agilent34980A* pT, IAgilent34980AMeasurement** val);
HRESULT IAgilent34980A_get_Memory(Agilent34980A* pT, IAgilent34980AMemory** val);
HRESULT IAgilent34980A_get_Period(Agilent34980A* pT, IAgilent34980APeriod** val);
HRESULT IAgilent34980A_get_Resistance(Agilent34980A* pT, IAgilent34980AResistance** val);
HRESULT IAgilent34980A_get_Route(Agilent34980A* pT, IAgilent34980ARoute** val);
HRESULT IAgilent34980A_get_Scale(Agilent34980A* pT, IAgilent34980AScale** val);
HRESULT IAgilent34980A_get_Scan(Agilent34980A* pT, IAgilent34980AScan** val);
HRESULT IAgilent34980A_get_Statistics(Agilent34980A* pT, IAgilent34980AStatistics** val);
HRESULT IAgilent34980A_get_Status(Agilent34980A* pT, IAgilent34980AStatus** val);
HRESULT IAgilent34980A_get_System(Agilent34980A* pT, IAgilent34980ASystem** val);
HRESULT IAgilent34980A_get_Temperature(Agilent34980A* pT, IAgilent34980ATemperature** val);
HRESULT IAgilent34980A_get_Voltage(Agilent34980A* pT, IAgilent34980AVoltage** val);
HRESULT IAgilent34980A_get_Personality(Agilent34980A* pT, IAgilent34980APersonality** val);
HRESULT IAgilent34980A_get_Trigger(Agilent34980A* pT, IAgilent34980ATrigger** val);
HRESULT IAgilent34980APersonality_Select(Agilent34980A* pT, BSTR personalityName, IUnknown** val);
HRESULT IAgilent34980APersonality_GetPersonalityNames(Agilent34980A* pT, SAFEARRAY** val);
HRESULT IIviDmmAC_ConfigureBandwidth(Agilent34980A* pT, double MinFreq, double MaxFreq);
HRESULT IIviDmmAC_get_FrequencyMax(Agilent34980A* pT, double* val);
HRESULT IIviDmmAC_put_FrequencyMax(Agilent34980A* pT, double val);
HRESULT IIviDmmAC_get_FrequencyMin(Agilent34980A* pT, double* val);
HRESULT IIviDmmAC_put_FrequencyMin(Agilent34980A* pT, double val);
HRESULT IIviDmmAdvanced_get_ActualRange(Agilent34980A* pT, double* val);
HRESULT IIviDmmAdvanced_get_ApertureTime(Agilent34980A* pT, double* val);
HRESULT IIviDmmAdvanced_get_ApertureTimeUnits(Agilent34980A* pT, IviDmmApertureTimeUnitsEnum* val);
HRESULT IIviDmmAdvanced_get_AutoZero(Agilent34980A* pT, IviDmmAutoZeroEnum* val);
HRESULT IIviDmmAdvanced_put_AutoZero(Agilent34980A* pT, IviDmmAutoZeroEnum val);
HRESULT IIviDmmAdvanced_get_PowerlineFrequency(Agilent34980A* pT, double* val);
HRESULT IIviDmmAdvanced_put_PowerlineFrequency(Agilent34980A* pT, double val);
HRESULT IIviDmmFrequency_get_VoltageRange(Agilent34980A* pT, double* val);
HRESULT IIviDmmFrequency_put_VoltageRange(Agilent34980A* pT, double val);
HRESULT IIviDmmMeasurement_IsOverRange(Agilent34980A* pT, double MeasurementValue, VARIANT_BOOL* val);
HRESULT IIviDmmMeasurement_SendSoftwareTrigger(Agilent34980A* pT);
HRESULT IIviDmmMeasurement_ReadMultiPoint(Agilent34980A* pT, long MaxTimeMilliseconds, SAFEARRAY** val);
HRESULT IIviDmmMeasurement_Read(Agilent34980A* pT, long MaxTimeMilliseconds, double* val);
HRESULT IIviDmmMeasurement_FetchMultiPoint(Agilent34980A* pT, long MaxTimeMilliseconds, SAFEARRAY** val);
HRESULT IIviDmmMeasurement_Fetch(Agilent34980A* pT, long MaxTimeMilliseconds, double* val);
HRESULT IIviDmmMeasurement_Abort(Agilent34980A* pT);
HRESULT IIviDmmMeasurement_Initiate(Agilent34980A* pT);
HRESULT IIviDmmRTD_Configure(Agilent34980A* pT, double Alpha, double Resistance);
HRESULT IIviDmmRTD_get_Alpha(Agilent34980A* pT, double* val);
HRESULT IIviDmmRTD_put_Alpha(Agilent34980A* pT, double val);
HRESULT IIviDmmRTD_get_Resistance(Agilent34980A* pT, double* val);
HRESULT IIviDmmRTD_put_Resistance(Agilent34980A* pT, double val);
HRESULT IIviDmmThermocouple_Configure(Agilent34980A* pT, IviDmmThermocoupleTypeEnum Type, IviDmmRefJunctionTypeEnum RefJunctionType);
HRESULT IIviDmmThermocouple_get_FixedRefJunction(Agilent34980A* pT, double* val);
HRESULT IIviDmmThermocouple_put_FixedRefJunction(Agilent34980A* pT, double val);
HRESULT IIviDmmThermocouple_get_RefJunctionType(Agilent34980A* pT, IviDmmRefJunctionTypeEnum* val);
HRESULT IIviDmmThermocouple_put_RefJunctionType(Agilent34980A* pT, IviDmmRefJunctionTypeEnum val);
HRESULT IIviDmmThermocouple_get_Type(Agilent34980A* pT, IviDmmThermocoupleTypeEnum* val);
HRESULT IIviDmmThermocouple_put_Type(Agilent34980A* pT, IviDmmThermocoupleTypeEnum val);
HRESULT IIviDmmThermistor_get_Resistance(Agilent34980A* pT, double* val);
HRESULT IIviDmmThermistor_put_Resistance(Agilent34980A* pT, double val);
HRESULT IIviDmmTemperature_get_TransducerType(Agilent34980A* pT, IviDmmTransducerTypeEnum* val);
HRESULT IIviDmmTemperature_put_TransducerType(Agilent34980A* pT, IviDmmTransducerTypeEnum val);
HRESULT IIviDmmTemperature_get_RTD(Agilent34980A* pT, IIviDmmRTD** val);
HRESULT IIviDmmTemperature_get_Thermocouple(Agilent34980A* pT, IIviDmmThermocouple** val);
HRESULT IIviDmmTemperature_get_Thermistor(Agilent34980A* pT, IIviDmmThermistor** val);
HRESULT IIviDmmMultiPoint_Configure(Agilent34980A* pT, long TriggerCount, long SampleCount, IviDmmSampleTriggerEnum SampleTrigger, double SampleInterval);
HRESULT IIviDmmMultiPoint_get_MeasurementComplete(Agilent34980A* pT, IviDmmMeasCompleteDestEnum* val);
HRESULT IIviDmmMultiPoint_put_MeasurementComplete(Agilent34980A* pT, IviDmmMeasCompleteDestEnum val);
HRESULT IIviDmmMultiPoint_get_Count(Agilent34980A* pT, long* val);
HRESULT IIviDmmMultiPoint_put_Count(Agilent34980A* pT, long val);
HRESULT IIviDmmMultiPoint_get_SampleCount(Agilent34980A* pT, long* val);
HRESULT IIviDmmMultiPoint_put_SampleCount(Agilent34980A* pT, long val);
HRESULT IIviDmmMultiPoint_get_SampleInterval(Agilent34980A* pT, double* val);
HRESULT IIviDmmMultiPoint_put_SampleInterval(Agilent34980A* pT, double val);
HRESULT IIviDmmMultiPoint_get_SampleTrigger(Agilent34980A* pT, IviDmmSampleTriggerEnum* val);
HRESULT IIviDmmMultiPoint_put_SampleTrigger(Agilent34980A* pT, IviDmmSampleTriggerEnum val);
HRESULT IIviDmmTrigger_Configure(Agilent34980A* pT, IviDmmTriggerSourceEnum TriggerSource, double TriggerDelay);
HRESULT IIviDmmTrigger_get_Slope(Agilent34980A* pT, IviDmmTriggerSlopeEnum* val);
HRESULT IIviDmmTrigger_put_Slope(Agilent34980A* pT, IviDmmTriggerSlopeEnum val);
HRESULT IIviDmmTrigger_get_Delay(Agilent34980A* pT, double* val);
HRESULT IIviDmmTrigger_put_Delay(Agilent34980A* pT, double val);
HRESULT IIviDmmTrigger_get_Source(Agilent34980A* pT, IviDmmTriggerSourceEnum* val);
HRESULT IIviDmmTrigger_put_Source(Agilent34980A* pT, IviDmmTriggerSourceEnum val);
HRESULT IIviDmmTrigger_get_MultiPoint(Agilent34980A* pT, IIviDmmMultiPoint** val);
HRESULT IIviDmm_Configure(Agilent34980A* pT, IviDmmFunctionEnum Function, double Range, double Resolution);
HRESULT IIviDmm_get_Function(Agilent34980A* pT, IviDmmFunctionEnum* val);
HRESULT IIviDmm_put_Function(Agilent34980A* pT, IviDmmFunctionEnum val);
HRESULT IIviDmm_get_Range(Agilent34980A* pT, double* val);
HRESULT IIviDmm_put_Range(Agilent34980A* pT, double val);
HRESULT IIviDmm_get_Resolution(Agilent34980A* pT, double* val);
HRESULT IIviDmm_put_Resolution(Agilent34980A* pT, double val);
HRESULT IIviDmm_get_AC(Agilent34980A* pT, IIviDmmAC** val);
HRESULT IIviDmm_get_Advanced(Agilent34980A* pT, IIviDmmAdvanced** val);
HRESULT IIviDmm_get_Frequency(Agilent34980A* pT, IIviDmmFrequency** val);
HRESULT IIviDmm_get_Measurement(Agilent34980A* pT, IIviDmmMeasurement** val);
HRESULT IIviDmm_get_Temperature(Agilent34980A* pT, IIviDmmTemperature** val);
HRESULT IIviDmm_get_Trigger(Agilent34980A* pT, IIviDmmTrigger** val);
HRESULT IIviDriver_Close(Agilent34980A* pT);
HRESULT IIviDriver_Initialize(Agilent34980A* pT, BSTR ResourceName, VARIANT_BOOL IdQuery, VARIANT_BOOL Reset, BSTR OptionString);
HRESULT IIviDriver_get_DriverOperation(Agilent34980A* pT, IIviDriverOperation** val);
HRESULT IIviDriver_get_Identity(Agilent34980A* pT, IIviDriverIdentity** val);
HRESULT IIviDriver_get_Utility(Agilent34980A* pT, IIviDriverUtility** val);
HRESULT IIviDriver_get_Initialized(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviDriverOperation_GetNextCoercionRecord(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverOperation_ResetInterchangeCheck(Agilent34980A* pT);
HRESULT IIviDriverOperation_GetNextInterchangeWarning(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverOperation_ClearInterchangeWarnings(Agilent34980A* pT);
HRESULT IIviDriverOperation_InvalidateAllAttributes(Agilent34980A* pT);
HRESULT IIviDriverOperation_get_LogicalName(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverOperation_get_IoResourceDescriptor(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverOperation_get_Cache(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviDriverOperation_put_Cache(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IIviDriverOperation_get_InterchangeCheck(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviDriverOperation_put_InterchangeCheck(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IIviDriverOperation_get_QueryInstrumentStatus(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviDriverOperation_put_QueryInstrumentStatus(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IIviDriverOperation_get_RangeCheck(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviDriverOperation_put_RangeCheck(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IIviDriverOperation_get_RecordCoercions(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviDriverOperation_put_RecordCoercions(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IIviDriverOperation_get_Simulate(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviDriverOperation_put_Simulate(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IIviDriverOperation_get_DriverSetup(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverIdentity_get_InstrumentManufacturer(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverIdentity_get_InstrumentModel(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverIdentity_get_InstrumentFirmwareRevision(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverIdentity_get_Identifier(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverIdentity_get_SupportedInstrumentModels(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverIdentity_get_SpecificationMajorVersion(Agilent34980A* pT, long* val);
HRESULT IIviDriverIdentity_get_SpecificationMinorVersion(Agilent34980A* pT, long* val);
HRESULT IIviDriverIdentity_get_GroupCapabilities(Agilent34980A* pT, BSTR* val);
HRESULT IIviComponentIdentity_get_Description(Agilent34980A* pT, BSTR* val);
HRESULT IIviComponentIdentity_get_Revision(Agilent34980A* pT, BSTR* val);
HRESULT IIviComponentIdentity_get_Vendor(Agilent34980A* pT, BSTR* val);
HRESULT IIviDriverUtility_UnlockObject(Agilent34980A* pT);
HRESULT IIviDriverUtility_LockObject(Agilent34980A* pT);
HRESULT IIviDriverUtility_ErrorQuery(Agilent34980A* pT, long* ErrorCode, BSTR* ErrorMessage);
HRESULT IIviDriverUtility_SelfTest(Agilent34980A* pT, long* TestResult, BSTR* TestMessage);
HRESULT IIviDriverUtility_Disable(Agilent34980A* pT);
HRESULT IIviDriverUtility_ResetWithDefaults(Agilent34980A* pT);
HRESULT IIviDriverUtility_Reset(Agilent34980A* pT);
HRESULT IAgilent34980AAlarm_Clear(Agilent34980A* pT, VARIANT_BOOL ClearAll, long Index);
HRESULT IAgilent34980AAlarm_AlarmScanSetup(Agilent34980A* pT, BSTR ChannelList, long Channel, long AlarmIndex, long NumSweeps, double UpperLimit);
HRESULT IAgilent34980AAlarm_get_LowerLimit(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AAlarm_put_LowerLimit(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AAlarm_get_LowerLimitEnable(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AAlarm_put_LowerLimitEnable(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AAlarm_get_Mode(Agilent34980A* pT, Agilent34980AAlarmModeEnum* val);
HRESULT IAgilent34980AAlarm_put_Mode(Agilent34980A* pT, Agilent34980AAlarmModeEnum val);
HRESULT IAgilent34980AAlarm_get_QueryAlarmQueue(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980AAlarm_get_Slope(Agilent34980A* pT, Agilent34980ASlopeEnum* val);
HRESULT IAgilent34980AAlarm_put_Slope(Agilent34980A* pT, Agilent34980ASlopeEnum val);
HRESULT IAgilent34980AAlarm_get_Source(Agilent34980A* pT, long Index, BSTR* val);
HRESULT IAgilent34980AAlarm_put_Source(Agilent34980A* pT, long Index, BSTR val);
HRESULT IAgilent34980AAlarm_get_UpperLimit(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AAlarm_put_UpperLimit(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AAlarm_get_UpperLimitEnable(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AAlarm_put_UpperLimitEnable(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AACVoltage_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution);
HRESULT IAgilent34980AACVoltage_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980AACVoltage_get_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AACVoltage_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AACVoltage_get_Bandwidth(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AACVoltage_put_Bandwidth(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AACVoltage_get_Range(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AACVoltage_put_Range(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AACCurrent_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution);
HRESULT IAgilent34980AACCurrent_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980AACCurrent_get_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AACCurrent_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AACCurrent_get_Bandwidth(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AACCurrent_put_Bandwidth(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AACCurrent_get_Range(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AACCurrent_put_Range(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ACalibration_SecurityEnable(Agilent34980A* pT, VARIANT_BOOL Enable, BSTR Code);
HRESULT IAgilent34980ACalibration_put_Code(Agilent34980A* pT, BSTR val);
HRESULT IAgilent34980ACalibration_get_String(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ACalibration_put_String(Agilent34980A* pT, BSTR val);
HRESULT IAgilent34980ACalibration_get_Count(Agilent34980A* pT, long* val);
HRESULT IAgilent34980ACalibration_get_LineFrequency(Agilent34980A* pT, double* val);
HRESULT IAgilent34980ACalibration_put_LineFrequency(Agilent34980A* pT, double val);
HRESULT IAgilent34980ACalibration_get_SecurityState(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ACalibration_get_DAC(Agilent34980A* pT, IAgilent34980ADAC** val);
HRESULT IAgilent34980ACalibration_get_DMM(Agilent34980A* pT, IAgilent34980ADMM** val);
HRESULT IAgilent34980ACurrent_get_ACCurrent(Agilent34980A* pT, IAgilent34980AACCurrent** val);
HRESULT IAgilent34980ACurrent_get_DCCurrent(Agilent34980A* pT, IAgilent34980ADCCurrent** val);
HRESULT IAgilent34980ADCCurrent_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution);
HRESULT IAgilent34980ADCCurrent_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980ADCCurrent_get_Aperture(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ADCCurrent_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ADCCurrent_get_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980ADCCurrent_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980ADCCurrent_get_NPLC(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ADCCurrent_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ADCCurrent_get_Range(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ADCCurrent_put_Range(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ADCCurrent_get_Resolution(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ADCCurrent_get_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum* val);
HRESULT IAgilent34980ADCCurrent_put_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum val);
HRESULT IAgilent34980ADCVoltage_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution);
HRESULT IAgilent34980ADCVoltage_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980ADCVoltage_get_Aperture(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ADCVoltage_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ADCVoltage_get_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980ADCVoltage_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980ADCVoltage_get_NPLC(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ADCVoltage_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ADCVoltage_get_Range(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ADCVoltage_put_Range(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ADCVoltage_get_Resolution(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ADCVoltage_get_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum* val);
HRESULT IAgilent34980ADCVoltage_put_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum val);
HRESULT IAgilent34980ADCVoltage_get_AutoImpedance(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980ADCVoltage_put_AutoImpedance(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980ADiagnostic_RelayCyclesClear(Agilent34980A* pT, BSTR ChannelList);
HRESULT IAgilent34980ADiagnostic_DMMCyclesClear(Agilent34980A* pT, long Index);
HRESULT IAgilent34980ADiagnostic_get_DMMCycles(Agilent34980A* pT, long Index, long* val);
HRESULT IAgilent34980ADiagnostic_get_RelayCycles(Agilent34980A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34980ADisplay_ClearDisplay(Agilent34980A* pT);
HRESULT IAgilent34980ADisplay_MonitorDMM(Agilent34980A* pT);
HRESULT IAgilent34980ADisplay_MonitorChannel(Agilent34980A* pT, BSTR Channel);
HRESULT IAgilent34980ADisplay_get_DisplayEnabled(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ADisplay_put_DisplayEnabled(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980ADisplay_get_DisplayText(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ADisplay_put_DisplayText(Agilent34980A* pT, BSTR val);
HRESULT IAgilent34980ADisplay_get_MonitorData(Agilent34980A* pT, double* val);
HRESULT IAgilent34980ADisplay_get_MonitorEnable(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ADisplay_put_MonitorEnable(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980ADisplay_get_MonitorMode(Agilent34980A* pT, Agilent34980AMonitorModeEnum* val);
HRESULT IAgilent34980ADisplay_put_MonitorMode(Agilent34980A* pT, Agilent34980AMonitorModeEnum val);
HRESULT IAgilent34980ADisplay_get_EnableMonitorChan(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980ADisplay_put_EnableMonitorChan(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980ADisplay_get_SelectMonitorChan(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ADisplay_put_SelectMonitorChan(Agilent34980A* pT, BSTR val);
HRESULT IAgilent34980AFrequency_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980AFrequency_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution);
HRESULT IAgilent34980AFrequency_get_Aperture(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AFrequency_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AFrequency_get_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AFrequency_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AFrequency_get_LowRange(Agilent34980A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34980AFrequency_put_LowRange(Agilent34980A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34980AFrequency_get_Range(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AFResistance_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution);
HRESULT IAgilent34980AFResistance_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980AFResistance_get_Aperture(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AFResistance_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AFResistance_get_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AFResistance_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AFResistance_get_NPLC(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AFResistance_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AFResistance_get_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AFResistance_put_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AFResistance_get_Range(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AFResistance_put_Range(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AFResistance_get_Resolution(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AMeasurement_Initiate(Agilent34980A* pT);
HRESULT IAgilent34980AMeasurement_Abort(Agilent34980A* pT);
HRESULT IAgilent34980AMeasurement_DestructiveRead(Agilent34980A* pT, long MaxCount, SAFEARRAY** val);
HRESULT IAgilent34980AMeasurement_Fetch(Agilent34980A* pT, SAFEARRAY** val);
HRESULT IAgilent34980AMeasurement_FetchNumbersOnly(Agilent34980A* pT, SAFEARRAY** val);
HRESULT IAgilent34980AMeasurement_QueryLast(Agilent34980A* pT, BSTR Channel, double* val);
HRESULT IAgilent34980AMeasurement_Read(Agilent34980A* pT, BSTR ChannelList, SAFEARRAY** val);
HRESULT IAgilent34980AMeasurement_ReadNumbersOnly(Agilent34980A* pT, BSTR ChannelList, SAFEARRAY** val);
HRESULT IAgilent34980AMeasurement_RemoveReadings(Agilent34980A* pT, long NumReadings, SAFEARRAY** val);
HRESULT IAgilent34980AMeasurement_SendSoftwareTrigger(Agilent34980A* pT);
HRESULT IAgilent34980AMeasurement_get_DataFormat(Agilent34980A* pT, IAgilent34980ADataFormat** val);
HRESULT IAgilent34980AMeasurement_get_ReadingCount(Agilent34980A* pT, long* val);
HRESULT IAgilent34980AMeasurement_get_MeasurementFunction(Agilent34980A* pT, BSTR Channel, BSTR* val);
HRESULT IAgilent34980AMeasurement_put_MeasurementFunction(Agilent34980A* pT, BSTR Channel, BSTR val);
HRESULT IAgilent34980AMemory_SaveState(Agilent34980A* pT, BSTR Identifier);
HRESULT IAgilent34980AMemory_RecallState(Agilent34980A* pT, BSTR Identifier);
HRESULT IAgilent34980AMemory_DeleteLocation(Agilent34980A* pT, long LocationNum, VARIANT_BOOL DeleteAll);
HRESULT IAgilent34980AMemory_get_AutoRecall(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980AMemory_put_AutoRecall(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980AMemory_get_NumStates(Agilent34980A* pT, long* val);
HRESULT IAgilent34980AMemory_get_StateName(Agilent34980A* pT, long LocationNum, BSTR* val);
HRESULT IAgilent34980AMemory_put_StateName(Agilent34980A* pT, long LocationNum, BSTR val);
HRESULT IAgilent34980AMemory_get_ValidState(Agilent34980A* pT, long LocationNum, VARIANT_BOOL* val);
HRESULT IAgilent34980AMemory_get_Catalog(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980APeriod_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution);
HRESULT IAgilent34980APeriod_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980APeriod_get_Aperture(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980APeriod_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980APeriod_get_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980APeriod_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980APeriod_get_Range(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AResistance_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution);
HRESULT IAgilent34980AResistance_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980AResistance_get_Aperture(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AResistance_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AResistance_get_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AResistance_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AResistance_get_NPLC(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AResistance_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AResistance_get_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AResistance_put_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AResistance_get_Range(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AResistance_put_Range(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AResistance_get_Resolution(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AResistance_get_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum* val);
HRESULT IAgilent34980AResistance_put_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum val);
HRESULT IAgilent34980AScale_OffsetNull(Agilent34980A* pT, BSTR ChannelList);
HRESULT IAgilent34980AScale_get_Gain(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AScale_put_Gain(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AScale_get_Offset(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AScale_put_Offset(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AScale_get_State(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AScale_put_State(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AScale_get_Unit(Agilent34980A* pT, BSTR ChannelList, BSTR* val);
HRESULT IAgilent34980AScale_put_Unit(Agilent34980A* pT, BSTR ChannelList, BSTR val);
HRESULT IAgilent34980ARoute_CloseExclusive(Agilent34980A* pT, BSTR ChannelList);
HRESULT IAgilent34980ARoute_Close(Agilent34980A* pT, BSTR ChannelList);
HRESULT IAgilent34980ARoute_Open(Agilent34980A* pT, BSTR ChannelList);
HRESULT IAgilent34980ARoute_OpenAll(Agilent34980A* pT, long Slot);
HRESULT IAgilent34980ARoute_get_AutoDelay(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980ARoute_put_AutoDelay(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980ARoute_get_Delay(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ARoute_put_Delay(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ARoute_get_FWire(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980ARoute_put_FWire(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980ARoute_get_Done(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ARoute_get_IsClosed(Agilent34980A* pT, BSTR Channel, VARIANT_BOOL* val);
HRESULT IAgilent34980AScan_ConfigureScan(Agilent34980A* pT, BSTR ChannelList, long SweepCount, VARIANT_BOOL Ordered);
HRESULT IAgilent34980AScan_get_ScanSize(Agilent34980A* pT, long* val);
HRESULT IAgilent34980AScan_get_ScanList(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980AScan_put_ScanList(Agilent34980A* pT, BSTR val);
HRESULT IAgilent34980AScan_get_ScanTime(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980AScan_get_SweepCount(Agilent34980A* pT, long* val);
HRESULT IAgilent34980AScan_put_SweepCount(Agilent34980A* pT, long val);
HRESULT IAgilent34980AScan_get_OrderedScan(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980AScan_put_OrderedScan(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980AStatistics_ClearStatistics(Agilent34980A* pT, BSTR ChannelList);
HRESULT IAgilent34980AStatistics_get_Average(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AStatistics_get_Count(Agilent34980A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34980AStatistics_get_MaxValue(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AStatistics_get_MaxValueTime(Agilent34980A* pT, BSTR ChannelList, BSTR* val);
HRESULT IAgilent34980AStatistics_get_MinValue(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AStatistics_get_MinValueTime(Agilent34980A* pT, BSTR ChannelList, BSTR* val);
HRESULT IAgilent34980AStatistics_get_PTPeak(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AStatus_Preset(Agilent34980A* pT);
HRESULT IAgilent34980AStatus_ConfigureServiceRequest(Agilent34980A* pT, Agilent34980ASRQReasonEnum Reason);
HRESULT IAgilent34980AStatus_Clear(Agilent34980A* pT);
HRESULT IAgilent34980AStatus_get_Register(Agilent34980A* pT, Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long* val);
HRESULT IAgilent34980AStatus_put_Register(Agilent34980A* pT, Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long val);
HRESULT IAgilent34980AStatus_get_SerialPoll(Agilent34980A* pT, long* val);
HRESULT IAgilent34980ASystem_WaitForOperationComplete(Agilent34980A* pT, long MaxTimeMilliseconds);
HRESULT IAgilent34980ASystem_SetSystemTime(Agilent34980A* pT, long Hours, long Mins, double Seconds);
HRESULT IAgilent34980ASystem_SetSystemDate(Agilent34980A* pT, long Year, long Month, long Day);
HRESULT IAgilent34980ASystem_Preset(Agilent34980A* pT);
HRESULT IAgilent34980ASystem_GetSystemTime(Agilent34980A* pT, long* Hours, long* Mins, double* Seconds);
HRESULT IAgilent34980ASystem_GetSystemDate(Agilent34980A* pT, long* Year, long* Month, long* Day);
HRESULT IAgilent34980ASystem_CardReset(Agilent34980A* pT, long SlotNum);
HRESULT IAgilent34980ASystem_LockRequest(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ASystem_LockRelease(Agilent34980A* pT);
HRESULT IAgilent34980ASystem_SecureImmediate(Agilent34980A* pT);
HRESULT IAgilent34980ASystem_GetModuleTemperature(Agilent34980A* pT, Agilent34980AModuleTemperatureEnum Mode, long Slot, double* val);
HRESULT IAgilent34980ASystem_get_AsyncEventsEnabled(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ASystem_put_AsyncEventsEnabled(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980ASystem_get_CardType(Agilent34980A* pT, long SlotNum, BSTR* val);
HRESULT IAgilent34980ASystem_get_Date(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ASystem_put_Date(Agilent34980A* pT, BSTR val);
HRESULT IAgilent34980ASystem_get_DMMEnabled(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ASystem_put_DMMEnabled(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980ASystem_get_DMMInstalled(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ASystem_get_ReadingThreshold(Agilent34980A* pT, long* val);
HRESULT IAgilent34980ASystem_put_ReadingThreshold(Agilent34980A* pT, long val);
HRESULT IAgilent34980ASystem_get_SerialNumber(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ASystem_get_Time(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ASystem_put_Time(Agilent34980A* pT, BSTR val);
HRESULT IAgilent34980ASystem_get_TimeoutMilliseconds(Agilent34980A* pT, long* val);
HRESULT IAgilent34980ASystem_put_TimeoutMilliseconds(Agilent34980A* pT, long val);
HRESULT IAgilent34980ASystem_get_IO(Agilent34980A* pT, IFormattedIO488** val);
HRESULT IAgilent34980ASystem_get_EnableInterface(Agilent34980A* pT, Agilent34980AHWInterfaceEnum HWInterface, VARIANT_BOOL* val);
HRESULT IAgilent34980ASystem_put_EnableInterface(Agilent34980A* pT, Agilent34980AHWInterfaceEnum HWInterface, VARIANT_BOOL val);
HRESULT IAgilent34980ASystem_get_LockOwner(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ASystem_put_ModuleWireMode(Agilent34980A* pT, long SlotNumber, Agilent34980AWireModeEnum val);
HRESULT IAgilent34980ASystem_get_ModuleEvents(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ATemperature_get_ReadingUnits(Agilent34980A* pT, BSTR ChannelList, Agilent34980ATemperatureUnitsEnum* val);
HRESULT IAgilent34980ATemperature_put_ReadingUnits(Agilent34980A* pT, BSTR ChannelList, Agilent34980ATemperatureUnitsEnum val);
HRESULT IAgilent34980ATemperature_get_FRTD(Agilent34980A* pT, IAgilent34980AFRTD** val);
HRESULT IAgilent34980ATemperature_get_RTD(Agilent34980A* pT, IAgilent34980ARTD** val);
HRESULT IAgilent34980ATemperature_get_Thermocouple(Agilent34980A* pT, IAgilent34980AThermocouple** val);
HRESULT IAgilent34980ATemperature_get_Thermistor(Agilent34980A* pT, IAgilent34980AThermistor** val);
HRESULT IAgilent34980ATemperature_get_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum* val);
HRESULT IAgilent34980ATemperature_put_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum val);
HRESULT IAgilent34980ATemperature_get_NPLC(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ATemperature_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ATemperature_get_TransducerType(Agilent34980A* pT, BSTR ChannelList, Agilent34980ATransducerEnum* val);
HRESULT IAgilent34980ATemperature_put_TransducerType(Agilent34980A* pT, BSTR ChannelList, Agilent34980ATransducerEnum val);
HRESULT IAgilent34980AVoltage_get_ACVoltage(Agilent34980A* pT, IAgilent34980AACVoltage** val);
HRESULT IAgilent34980AVoltage_get_DCVoltage(Agilent34980A* pT, IAgilent34980ADCVoltage** val);
HRESULT IAgilent34980AFRTD_Configure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AFRTDAlphaEnum Type);
HRESULT IAgilent34980AFRTD_Measure(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARTDAlphaEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980AFRTD_get_Resistance(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AFRTD_put_Resistance(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AFRTD_get_Alpha(Agilent34980A* pT, BSTR ChannelList, Agilent34980AFRTDAlphaEnum* val);
HRESULT IAgilent34980AFRTD_put_Alpha(Agilent34980A* pT, BSTR ChannelList, Agilent34980AFRTDAlphaEnum val);
HRESULT IAgilent34980AFRTD_get_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AFRTD_put_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AFRTD_get_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AFRTD_put_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980ADataFormat_Configure(Agilent34980A* pT, VARIANT_BOOL EnableAlarm, VARIANT_BOOL EnableChannel, VARIANT_BOOL EnableTime, Agilent34980ATimeOffsetEnum TimeType, VARIANT_BOOL EnableUnit);
HRESULT IAgilent34980ADataFormat_get_AlarmEnable(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ADataFormat_put_AlarmEnable(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980ADataFormat_get_ChannelEnable(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ADataFormat_put_ChannelEnable(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980ADataFormat_get_TimeEnable(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ADataFormat_put_TimeEnable(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980ADataFormat_get_TimeType(Agilent34980A* pT, Agilent34980ATimeOffsetEnum* val);
HRESULT IAgilent34980ADataFormat_put_TimeType(Agilent34980A* pT, Agilent34980ATimeOffsetEnum val);
HRESULT IAgilent34980ADataFormat_get_UnitEnable(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ADataFormat_put_UnitEnable(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IAgilent34980ARTD_Configure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980ARTDAlphaEnum Type);
HRESULT IAgilent34980ARTD_Measure(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARTDAlphaEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980ARTD_get_Resistance(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ARTD_put_Resistance(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980ARTD_get_Alpha(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARTDAlphaEnum* val);
HRESULT IAgilent34980ARTD_put_Alpha(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARTDAlphaEnum val);
HRESULT IAgilent34980ARTD_get_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980ARTD_put_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980ARTD_get_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980ARTD_put_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AThermistor_Configure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AThermistorEnum Type);
HRESULT IAgilent34980AThermistor_Measure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermistorEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980AThermistor_get_Resistance(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermistorEnum* val);
HRESULT IAgilent34980AThermistor_put_Resistance(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermistorEnum val);
HRESULT IAgilent34980AThermistor_get_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AThermistor_put_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AThermocouple_Configure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AThermocoupleEnum Type);
HRESULT IAgilent34980AThermocouple_Measure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermocoupleEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val);
HRESULT IAgilent34980AThermocouple_get_ThermocoupleType(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermocoupleEnum* val);
HRESULT IAgilent34980AThermocouple_put_ThermocoupleType(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermocoupleEnum val);
HRESULT IAgilent34980AThermocouple_get_ReferenceJunctionType(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARJunctionEnum* val);
HRESULT IAgilent34980AThermocouple_put_ReferenceJunctionType(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARJunctionEnum val);
HRESULT IAgilent34980AThermocouple_get_FixedReferenceJunction(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980AThermocouple_put_FixedReferenceJunction(Agilent34980A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34980AThermocouple_get_Check(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AThermocouple_put_Check(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AThermocouple_get_AutoImpedance(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34980AThermocouple_put_AutoImpedance(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34980AThermocouple_get_ExternalReferenceJunction(Agilent34980A* pT, double* val);
HRESULT IAgilent34980AThermocouple_get_InternalReferenceJunction(Agilent34980A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34980ATrigger_Configure(Agilent34980A* pT, Agilent34980ATriggerSourceEnum Source, long TriggerCount, double Timer, long SampleCount);
HRESULT IAgilent34980ATrigger_get_SampleCount(Agilent34980A* pT, long* val);
HRESULT IAgilent34980ATrigger_put_SampleCount(Agilent34980A* pT, long val);
HRESULT IAgilent34980ATrigger_get_Count(Agilent34980A* pT, long* val);
HRESULT IAgilent34980ATrigger_put_Count(Agilent34980A* pT, long val);
HRESULT IAgilent34980ATrigger_get_Source(Agilent34980A* pT, Agilent34980ATriggerSourceEnum* val);
HRESULT IAgilent34980ATrigger_put_Source(Agilent34980A* pT, Agilent34980ATriggerSourceEnum val);
HRESULT IAgilent34980ATrigger_get_Timer(Agilent34980A* pT, double* val);
HRESULT IAgilent34980ATrigger_put_Timer(Agilent34980A* pT, double val);
HRESULT IAgilent34980ATrigger_get_Delay(Agilent34980A* pT, double* val);
HRESULT IAgilent34980ATrigger_put_Delay(Agilent34980A* pT, double val);
HRESULT IAgilent34980ATrigger_get_DelayAuto(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IAgilent34980ATrigger_put_DelayAuto(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IIviSwtch_get_Channels(Agilent34980A* pT, IIviSwtchChannels** val);
HRESULT IIviSwtch_get_Path(Agilent34980A* pT, IIviSwtchPath** val);
HRESULT IIviSwtch_get_Scan(Agilent34980A* pT, IIviSwtchScan** val);
HRESULT IIviSwtchChannels_get_Item(Agilent34980A* pT, BSTR Name, IIviSwtchChannel** val);
HRESULT IIviSwtchChannels_get_Count(Agilent34980A* pT, long* val);
HRESULT IIviSwtchChannels_get_Name(Agilent34980A* pT, long Index, BSTR* val);
HRESULT IIviSwtchPath_WaitForDebounce(Agilent34980A* pT, long MaxTimeMilliseconds);
HRESULT IIviSwtchPath_SetPath(Agilent34980A* pT, BSTR PathList);
HRESULT IIviSwtchPath_GetPath(Agilent34980A* pT, BSTR Channel1, BSTR Channel2, BSTR* val);
HRESULT IIviSwtchPath_DisconnectAll(Agilent34980A* pT);
HRESULT IIviSwtchPath_Disconnect(Agilent34980A* pT, BSTR Channel1, BSTR Channel2);
HRESULT IIviSwtchPath_Connect(Agilent34980A* pT, BSTR Channel1, BSTR Channel2);
HRESULT IIviSwtchPath_CanConnect(Agilent34980A* pT, BSTR Channel1, BSTR Channel2, IviSwtchPathCapabilityEnum* val);
HRESULT IIviSwtchPath_get_IsDebounced(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviSwtchScan_WaitForScanComplete(Agilent34980A* pT, long MaxTimeMilliseconds);
HRESULT IIviSwtchScan_SendSoftwareTrigger(Agilent34980A* pT);
HRESULT IIviSwtchScan_Abort(Agilent34980A* pT);
HRESULT IIviSwtchScan_Initiate(Agilent34980A* pT);
HRESULT IIviSwtchScan_ConfigureTrigger(Agilent34980A* pT, double ScanDelay, IviSwtchTriggerInputEnum TriggerInput, IviSwtchAdvancedOutputEnum AdvancedOutput);
HRESULT IIviSwtchScan_ConfigureList(Agilent34980A* pT, BSTR List, IviSwtchScanModeEnum Mode);
HRESULT IIviSwtchScan_get_IsScanning(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviSwtchScan_get_Continuous(Agilent34980A* pT, VARIANT_BOOL* val);
HRESULT IIviSwtchScan_put_Continuous(Agilent34980A* pT, VARIANT_BOOL val);
HRESULT IIviSwtchScan_get_NumberOfColumns(Agilent34980A* pT, long* val);
HRESULT IIviSwtchScan_get_NumberOfRows(Agilent34980A* pT, long* val);
HRESULT IIviSwtchScan_get_AdvancedOutput(Agilent34980A* pT, IviSwtchAdvancedOutputEnum* val);
HRESULT IIviSwtchScan_put_AdvancedOutput(Agilent34980A* pT, IviSwtchAdvancedOutputEnum val);
HRESULT IIviSwtchScan_get_Delay(Agilent34980A* pT, double* val);
HRESULT IIviSwtchScan_put_Delay(Agilent34980A* pT, double val);
HRESULT IIviSwtchScan_get_Input(Agilent34980A* pT, IviSwtchTriggerInputEnum* val);
HRESULT IIviSwtchScan_put_Input(Agilent34980A* pT, IviSwtchTriggerInputEnum val);
HRESULT IIviSwtchScan_get_List(Agilent34980A* pT, BSTR* val);
HRESULT IIviSwtchScan_put_List(Agilent34980A* pT, BSTR val);
HRESULT IIviSwtchScan_get_Mode(Agilent34980A* pT, IviSwtchScanModeEnum* val);
HRESULT IIviSwtchScan_put_Mode(Agilent34980A* pT, IviSwtchScanModeEnum val);
HRESULT IAgilent34980ADMM_PerformCalibration(Agilent34980A* pT);
HRESULT IAgilent34980ADMM_get_Count(Agilent34980A* pT, long* val);
HRESULT IAgilent34980ADMM_get_String(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ADMM_put_String(Agilent34980A* pT, BSTR val);
HRESULT IAgilent34980ADMM_get_Value(Agilent34980A* pT, double* val);
HRESULT IAgilent34980ADMM_put_Value(Agilent34980A* pT, double val);
HRESULT IAgilent34980ADAC_AutoCalibrate(Agilent34980A* pT, short SlotNumber, VARIANT_BOOL All);
HRESULT IAgilent34980ADAC_Abort(Agilent34980A* pT);
HRESULT IAgilent34980ADAC_BeginVoltageCal(Agilent34980A* pT, BSTR ChannelList, short SetupNumber);
HRESULT IAgilent34980ADAC_Point(Agilent34980A* pT, double PointData);
HRESULT IAgilent34980ADAC_get_Count(Agilent34980A* pT, short SlotNumber, long* val);
HRESULT IAgilent34980ADAC_get_String(Agilent34980A* pT, short SlotNumber, BSTR* val);
HRESULT IAgilent34980ADAC_put_String(Agilent34980A* pT, short SlotNumber, BSTR val);
HRESULT IAgilent34980AAlarm2_get_AlarmSequence(Agilent34980A* pT, long Index, BSTR* val);
HRESULT IAgilent34980A2_get_Alarm(Agilent34980A* pT, IAgilent34980AAlarm2** val);
HRESULT IAgilent34980A2_get_Route(Agilent34980A* pT, IAgilent34980ARoute2** val);
HRESULT IAgilent34980A2_get_Status(Agilent34980A* pT, IAgilent34980AStatus2** val);
HRESULT IAgilent34980A2_get_Calibration(Agilent34980A* pT, IAgilent34980ACalibration** val);
HRESULT IAgilent34980A2_get_Current(Agilent34980A* pT, IAgilent34980ACurrent** val);
HRESULT IAgilent34980A2_get_Diagnostic(Agilent34980A* pT, IAgilent34980ADiagnostic** val);
HRESULT IAgilent34980A2_get_Frequency(Agilent34980A* pT, IAgilent34980AFrequency** val);
HRESULT IAgilent34980A2_get_FResistance(Agilent34980A* pT, IAgilent34980AFResistance** val);
HRESULT IAgilent34980A2_get_Measurement(Agilent34980A* pT, IAgilent34980AMeasurement** val);
HRESULT IAgilent34980A2_get_Memory(Agilent34980A* pT, IAgilent34980AMemory** val);
HRESULT IAgilent34980A2_get_Period(Agilent34980A* pT, IAgilent34980APeriod** val);
HRESULT IAgilent34980A2_get_Personality(Agilent34980A* pT, IAgilent34980APersonality** val);
HRESULT IAgilent34980A2_get_Resistance(Agilent34980A* pT, IAgilent34980AResistance** val);
HRESULT IAgilent34980A2_get_Scale(Agilent34980A* pT, IAgilent34980AScale** val);
HRESULT IAgilent34980A2_get_Scan(Agilent34980A* pT, IAgilent34980AScan** val);
HRESULT IAgilent34980A2_get_Statistics(Agilent34980A* pT, IAgilent34980AStatistics** val);
HRESULT IAgilent34980A2_get_System(Agilent34980A* pT, IAgilent34980ASystem** val);
HRESULT IAgilent34980A2_get_Temperature(Agilent34980A* pT, IAgilent34980ATemperature** val);
HRESULT IAgilent34980A2_get_Trigger(Agilent34980A* pT, IAgilent34980ATrigger** val);
HRESULT IAgilent34980A2_get_Voltage(Agilent34980A* pT, IAgilent34980AVoltage** val);
HRESULT IAgilent34980A2_get_Display(Agilent34980A* pT, IAgilent34980ADisplay** val);
HRESULT IAgilent34980ARoute2_SequenceDefine(Agilent34980A* pT, BSTR SequenceName, BSTR CommandString);
HRESULT IAgilent34980ARoute2_SequenceDelete(Agilent34980A* pT, BSTR SequenceName);
HRESULT IAgilent34980ARoute2_SequenceDeleteAll(Agilent34980A* pT);
HRESULT IAgilent34980ARoute2_SequenceTriggerImmediate(Agilent34980A* pT, BSTR SequenceName);
HRESULT IAgilent34980ARoute2_get_ChannelLabel(Agilent34980A* pT, BSTR ChannelList, BSTR* val);
HRESULT IAgilent34980ARoute2_put_ChannelLabel(Agilent34980A* pT, BSTR ChannelList, BSTR val);
HRESULT IAgilent34980ARoute2_get_SequenceCatalog(Agilent34980A* pT, BSTR* val);
HRESULT IAgilent34980ARoute2_get_SequenceTriggerSource(Agilent34980A* pT, BSTR SequenceName, Agilent34980ASequenceTriggerSourceEnum* val);
HRESULT IAgilent34980ARoute2_put_SequenceTriggerSource(Agilent34980A* pT, BSTR SequenceName, Agilent34980ASequenceTriggerSourceEnum val);
HRESULT IAgilent34980AStatus2_get_ModuleRegister(Agilent34980A* pT, long Slot, Agilent34980AStatusSubRegisterEnum SubRegister, long* val);
HRESULT IAgilent34980AStatus2_put_ModuleRegister(Agilent34980A* pT, long Slot, Agilent34980AStatusSubRegisterEnum SubRegister, long val);
HRESULT IIviSwtchChannel_get_IsConfigurationChannel(Agilent34980AChannel* pT, VARIANT_BOOL* val);
HRESULT IIviSwtchChannel_put_IsConfigurationChannel(Agilent34980AChannel* pT, VARIANT_BOOL val);
HRESULT IIviSwtchChannel_get_IsSourceChannel(Agilent34980AChannel* pT, VARIANT_BOOL* val);
HRESULT IIviSwtchChannel_put_IsSourceChannel(Agilent34980AChannel* pT, VARIANT_BOOL val);
HRESULT IIviSwtchChannel_get_Characteristics(Agilent34980AChannel* pT, IIviSwtchCharacteristics** val);
HRESULT IIviSwtchCharacteristics_get_ACCurrentCarryMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_ACCurrentSwitchingMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_ACPowerCarryMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_ACPowerSwitchingMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_ACVoltageMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_Bandwidth(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_DCCurrentCarryMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_DCCurrentSwitchingMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_DCPowerCarryMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_DCPowerSwitchingMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_DCVoltageMax(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_Impedance(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_SettlingTime(Agilent34980AChannel* pT, double* val);
HRESULT IIviSwtchCharacteristics_get_WireMode(Agilent34980AChannel* pT, long* val);


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980A
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980A : public IAgilent34980A
{
	STDMETHODIMP Close()
	{
		return IIviDriver_Close(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Initialize(BSTR ResourceName, VARIANT_BOOL IdQuery, VARIANT_BOOL Reset, BSTR OptionString)
	{
		return IIviDriver_Initialize(static_cast<Deriving*>(this), ResourceName, IdQuery, Reset, OptionString);
	}
	STDMETHODIMP get_DriverOperation(IIviDriverOperation** val)
	{
		return IIviDriver_get_DriverOperation(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Identity(IIviDriverIdentity** val)
	{
		return IIviDriver_get_Identity(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Utility(IIviDriverUtility** val)
	{
		return IIviDriver_get_Utility(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Initialized(VARIANT_BOOL* val)
	{
		return IIviDriver_get_Initialized(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Alarm(IAgilent34980AAlarm** val)
	{
		return IAgilent34980A_get_Alarm(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Calibration(IAgilent34980ACalibration** val)
	{
		return IAgilent34980A_get_Calibration(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Current(IAgilent34980ACurrent** val)
	{
		return IAgilent34980A_get_Current(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Diagnostic(IAgilent34980ADiagnostic** val)
	{
		return IAgilent34980A_get_Diagnostic(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Display(IAgilent34980ADisplay** val)
	{
		return IAgilent34980A_get_Display(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Frequency(IAgilent34980AFrequency** val)
	{
		return IAgilent34980A_get_Frequency(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_FResistance(IAgilent34980AFResistance** val)
	{
		return IAgilent34980A_get_FResistance(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Measurement(IAgilent34980AMeasurement** val)
	{
		return IAgilent34980A_get_Measurement(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Memory(IAgilent34980AMemory** val)
	{
		return IAgilent34980A_get_Memory(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Period(IAgilent34980APeriod** val)
	{
		return IAgilent34980A_get_Period(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Resistance(IAgilent34980AResistance** val)
	{
		return IAgilent34980A_get_Resistance(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Route(IAgilent34980ARoute** val)
	{
		return IAgilent34980A_get_Route(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Scale(IAgilent34980AScale** val)
	{
		return IAgilent34980A_get_Scale(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Scan(IAgilent34980AScan** val)
	{
		return IAgilent34980A_get_Scan(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Statistics(IAgilent34980AStatistics** val)
	{
		return IAgilent34980A_get_Statistics(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Status(IAgilent34980AStatus** val)
	{
		return IAgilent34980A_get_Status(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_System(IAgilent34980ASystem** val)
	{
		return IAgilent34980A_get_System(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Temperature(IAgilent34980ATemperature** val)
	{
		return IAgilent34980A_get_Temperature(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Voltage(IAgilent34980AVoltage** val)
	{
		return IAgilent34980A_get_Voltage(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Personality(IAgilent34980APersonality** val)
	{
		return IAgilent34980A_get_Personality(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Trigger(IAgilent34980ATrigger** val)
	{
		return IAgilent34980A_get_Trigger(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980A<Agilent34980A> _IAgilent34980A;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980APersonality
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980APersonality : public IAgilent34980APersonality
{
	STDMETHODIMP Select(BSTR personalityName, IUnknown** val)
	{
		return IAgilent34980APersonality_Select(static_cast<Deriving*>(this), personalityName, val);
	}
	STDMETHODIMP GetPersonalityNames(SAFEARRAY** val)
	{
		return IAgilent34980APersonality_GetPersonalityNames(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980APersonality<Agilent34980A> _IAgilent34980APersonality;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmAC
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmAC : public IIviDmmAC
{
	STDMETHODIMP ConfigureBandwidth(double MinFreq, double MaxFreq)
	{
		return IIviDmmAC_ConfigureBandwidth(static_cast<Deriving*>(this), MinFreq, MaxFreq);
	}
	STDMETHODIMP get_FrequencyMax(double* val)
	{
		return IIviDmmAC_get_FrequencyMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_FrequencyMax(double val)
	{
		return IIviDmmAC_put_FrequencyMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_FrequencyMin(double* val)
	{
		return IIviDmmAC_get_FrequencyMin(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_FrequencyMin(double val)
	{
		return IIviDmmAC_put_FrequencyMin(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmAC<Agilent34980A> _IIviDmmAC;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmAdvanced
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmAdvanced : public IIviDmmAdvanced
{
	STDMETHODIMP get_ActualRange(double* val)
	{
		return IIviDmmAdvanced_get_ActualRange(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ApertureTime(double* val)
	{
		return IIviDmmAdvanced_get_ApertureTime(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ApertureTimeUnits(IviDmmApertureTimeUnitsEnum* val)
	{
		return IIviDmmAdvanced_get_ApertureTimeUnits(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_AutoZero(IviDmmAutoZeroEnum* val)
	{
		return IIviDmmAdvanced_get_AutoZero(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_AutoZero(IviDmmAutoZeroEnum val)
	{
		return IIviDmmAdvanced_put_AutoZero(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_PowerlineFrequency(double* val)
	{
		return IIviDmmAdvanced_get_PowerlineFrequency(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_PowerlineFrequency(double val)
	{
		return IIviDmmAdvanced_put_PowerlineFrequency(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmAdvanced<Agilent34980A> _IIviDmmAdvanced;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmFrequency
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmFrequency : public IIviDmmFrequency
{
	STDMETHODIMP get_VoltageRange(double* val)
	{
		return IIviDmmFrequency_get_VoltageRange(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_VoltageRange(double val)
	{
		return IIviDmmFrequency_put_VoltageRange(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmFrequency<Agilent34980A> _IIviDmmFrequency;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmMeasurement
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmMeasurement : public IIviDmmMeasurement
{
	STDMETHODIMP IsOverRange(double MeasurementValue, VARIANT_BOOL* val)
	{
		return IIviDmmMeasurement_IsOverRange(static_cast<Deriving*>(this), MeasurementValue, val);
	}
	STDMETHODIMP SendSoftwareTrigger()
	{
		return IIviDmmMeasurement_SendSoftwareTrigger(static_cast<Deriving*>(this));
	}
	STDMETHODIMP ReadMultiPoint(long MaxTimeMilliseconds, SAFEARRAY** val)
	{
		return IIviDmmMeasurement_ReadMultiPoint(static_cast<Deriving*>(this), MaxTimeMilliseconds, val);
	}
	STDMETHODIMP Read(long MaxTimeMilliseconds, double* val)
	{
		return IIviDmmMeasurement_Read(static_cast<Deriving*>(this), MaxTimeMilliseconds, val);
	}
	STDMETHODIMP FetchMultiPoint(long MaxTimeMilliseconds, SAFEARRAY** val)
	{
		return IIviDmmMeasurement_FetchMultiPoint(static_cast<Deriving*>(this), MaxTimeMilliseconds, val);
	}
	STDMETHODIMP Fetch(long MaxTimeMilliseconds, double* val)
	{
		return IIviDmmMeasurement_Fetch(static_cast<Deriving*>(this), MaxTimeMilliseconds, val);
	}
	STDMETHODIMP Abort()
	{
		return IIviDmmMeasurement_Abort(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Initiate()
	{
		return IIviDmmMeasurement_Initiate(static_cast<Deriving*>(this));
	}
};

typedef __IIviDmmMeasurement<Agilent34980A> _IIviDmmMeasurement;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmRTD
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmRTD : public IIviDmmRTD
{
	STDMETHODIMP Configure(double Alpha, double Resistance)
	{
		return IIviDmmRTD_Configure(static_cast<Deriving*>(this), Alpha, Resistance);
	}
	STDMETHODIMP get_Alpha(double* val)
	{
		return IIviDmmRTD_get_Alpha(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Alpha(double val)
	{
		return IIviDmmRTD_put_Alpha(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Resistance(double* val)
	{
		return IIviDmmRTD_get_Resistance(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Resistance(double val)
	{
		return IIviDmmRTD_put_Resistance(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmRTD<Agilent34980A> _IIviDmmRTD;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmThermocouple
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmThermocouple : public IIviDmmThermocouple
{
	STDMETHODIMP Configure(IviDmmThermocoupleTypeEnum Type, IviDmmRefJunctionTypeEnum RefJunctionType)
	{
		return IIviDmmThermocouple_Configure(static_cast<Deriving*>(this), Type, RefJunctionType);
	}
	STDMETHODIMP get_FixedRefJunction(double* val)
	{
		return IIviDmmThermocouple_get_FixedRefJunction(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_FixedRefJunction(double val)
	{
		return IIviDmmThermocouple_put_FixedRefJunction(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_RefJunctionType(IviDmmRefJunctionTypeEnum* val)
	{
		return IIviDmmThermocouple_get_RefJunctionType(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_RefJunctionType(IviDmmRefJunctionTypeEnum val)
	{
		return IIviDmmThermocouple_put_RefJunctionType(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Type(IviDmmThermocoupleTypeEnum* val)
	{
		return IIviDmmThermocouple_get_Type(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Type(IviDmmThermocoupleTypeEnum val)
	{
		return IIviDmmThermocouple_put_Type(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmThermocouple<Agilent34980A> _IIviDmmThermocouple;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmThermistor
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmThermistor : public IIviDmmThermistor
{
	STDMETHODIMP get_Resistance(double* val)
	{
		return IIviDmmThermistor_get_Resistance(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Resistance(double val)
	{
		return IIviDmmThermistor_put_Resistance(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmThermistor<Agilent34980A> _IIviDmmThermistor;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmTemperature
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmTemperature : public IIviDmmTemperature
{
	STDMETHODIMP get_TransducerType(IviDmmTransducerTypeEnum* val)
	{
		return IIviDmmTemperature_get_TransducerType(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_TransducerType(IviDmmTransducerTypeEnum val)
	{
		return IIviDmmTemperature_put_TransducerType(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_RTD(IIviDmmRTD** val)
	{
		return IIviDmmTemperature_get_RTD(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Thermocouple(IIviDmmThermocouple** val)
	{
		return IIviDmmTemperature_get_Thermocouple(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Thermistor(IIviDmmThermistor** val)
	{
		return IIviDmmTemperature_get_Thermistor(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmTemperature<Agilent34980A> _IIviDmmTemperature;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmMultiPoint
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmMultiPoint : public IIviDmmMultiPoint
{
	STDMETHODIMP Configure(long TriggerCount, long SampleCount, IviDmmSampleTriggerEnum SampleTrigger, double SampleInterval)
	{
		return IIviDmmMultiPoint_Configure(static_cast<Deriving*>(this), TriggerCount, SampleCount, SampleTrigger, SampleInterval);
	}
	STDMETHODIMP get_MeasurementComplete(IviDmmMeasCompleteDestEnum* val)
	{
		return IIviDmmMultiPoint_get_MeasurementComplete(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_MeasurementComplete(IviDmmMeasCompleteDestEnum val)
	{
		return IIviDmmMultiPoint_put_MeasurementComplete(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Count(long* val)
	{
		return IIviDmmMultiPoint_get_Count(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Count(long val)
	{
		return IIviDmmMultiPoint_put_Count(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SampleCount(long* val)
	{
		return IIviDmmMultiPoint_get_SampleCount(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_SampleCount(long val)
	{
		return IIviDmmMultiPoint_put_SampleCount(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SampleInterval(double* val)
	{
		return IIviDmmMultiPoint_get_SampleInterval(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_SampleInterval(double val)
	{
		return IIviDmmMultiPoint_put_SampleInterval(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SampleTrigger(IviDmmSampleTriggerEnum* val)
	{
		return IIviDmmMultiPoint_get_SampleTrigger(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_SampleTrigger(IviDmmSampleTriggerEnum val)
	{
		return IIviDmmMultiPoint_put_SampleTrigger(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmMultiPoint<Agilent34980A> _IIviDmmMultiPoint;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmmTrigger
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmmTrigger : public IIviDmmTrigger
{
	STDMETHODIMP Configure(IviDmmTriggerSourceEnum TriggerSource, double TriggerDelay)
	{
		return IIviDmmTrigger_Configure(static_cast<Deriving*>(this), TriggerSource, TriggerDelay);
	}
	STDMETHODIMP get_Slope(IviDmmTriggerSlopeEnum* val)
	{
		return IIviDmmTrigger_get_Slope(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Slope(IviDmmTriggerSlopeEnum val)
	{
		return IIviDmmTrigger_put_Slope(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Delay(double* val)
	{
		return IIviDmmTrigger_get_Delay(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Delay(double val)
	{
		return IIviDmmTrigger_put_Delay(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Source(IviDmmTriggerSourceEnum* val)
	{
		return IIviDmmTrigger_get_Source(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Source(IviDmmTriggerSourceEnum val)
	{
		return IIviDmmTrigger_put_Source(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_MultiPoint(IIviDmmMultiPoint** val)
	{
		return IIviDmmTrigger_get_MultiPoint(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmmTrigger<Agilent34980A> _IIviDmmTrigger;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDmm
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDmm : public IIviDmm
{
	STDMETHODIMP Close()
	{
		return IIviDriver_Close(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Initialize(BSTR ResourceName, VARIANT_BOOL IdQuery, VARIANT_BOOL Reset, BSTR OptionString)
	{
		return IIviDriver_Initialize(static_cast<Deriving*>(this), ResourceName, IdQuery, Reset, OptionString);
	}
	STDMETHODIMP get_DriverOperation(IIviDriverOperation** val)
	{
		return IIviDriver_get_DriverOperation(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Identity(IIviDriverIdentity** val)
	{
		return IIviDriver_get_Identity(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Utility(IIviDriverUtility** val)
	{
		return IIviDriver_get_Utility(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Initialized(VARIANT_BOOL* val)
	{
		return IIviDriver_get_Initialized(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP Configure(IviDmmFunctionEnum Function, double Range, double Resolution)
	{
		return IIviDmm_Configure(static_cast<Deriving*>(this), Function, Range, Resolution);
	}
	STDMETHODIMP get_Function(IviDmmFunctionEnum* val)
	{
		return IIviDmm_get_Function(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Function(IviDmmFunctionEnum val)
	{
		return IIviDmm_put_Function(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Range(double* val)
	{
		return IIviDmm_get_Range(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Range(double val)
	{
		return IIviDmm_put_Range(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Resolution(double* val)
	{
		return IIviDmm_get_Resolution(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Resolution(double val)
	{
		return IIviDmm_put_Resolution(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_AC(IIviDmmAC** val)
	{
		return IIviDmm_get_AC(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Advanced(IIviDmmAdvanced** val)
	{
		return IIviDmm_get_Advanced(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Frequency(IIviDmmFrequency** val)
	{
		return IIviDmm_get_Frequency(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Measurement(IIviDmmMeasurement** val)
	{
		return IIviDmm_get_Measurement(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Temperature(IIviDmmTemperature** val)
	{
		return IIviDmm_get_Temperature(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Trigger(IIviDmmTrigger** val)
	{
		return IIviDmm_get_Trigger(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDmm<Agilent34980A> _IIviDmm;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDriver
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDriver : public IIviDriver
{
	STDMETHODIMP Close()
	{
		return IIviDriver_Close(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Initialize(BSTR ResourceName, VARIANT_BOOL IdQuery, VARIANT_BOOL Reset, BSTR OptionString)
	{
		return IIviDriver_Initialize(static_cast<Deriving*>(this), ResourceName, IdQuery, Reset, OptionString);
	}
	STDMETHODIMP get_DriverOperation(IIviDriverOperation** val)
	{
		return IIviDriver_get_DriverOperation(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Identity(IIviDriverIdentity** val)
	{
		return IIviDriver_get_Identity(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Utility(IIviDriverUtility** val)
	{
		return IIviDriver_get_Utility(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Initialized(VARIANT_BOOL* val)
	{
		return IIviDriver_get_Initialized(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDriver<Agilent34980A> _IIviDriver;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDriverOperation
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDriverOperation : public IIviDriverOperation
{
	STDMETHODIMP GetNextCoercionRecord(BSTR* val)
	{
		return IIviDriverOperation_GetNextCoercionRecord(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP ResetInterchangeCheck()
	{
		return IIviDriverOperation_ResetInterchangeCheck(static_cast<Deriving*>(this));
	}
	STDMETHODIMP GetNextInterchangeWarning(BSTR* val)
	{
		return IIviDriverOperation_GetNextInterchangeWarning(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP ClearInterchangeWarnings()
	{
		return IIviDriverOperation_ClearInterchangeWarnings(static_cast<Deriving*>(this));
	}
	STDMETHODIMP InvalidateAllAttributes()
	{
		return IIviDriverOperation_InvalidateAllAttributes(static_cast<Deriving*>(this));
	}
	STDMETHODIMP get_LogicalName(BSTR* val)
	{
		return IIviDriverOperation_get_LogicalName(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_IoResourceDescriptor(BSTR* val)
	{
		return IIviDriverOperation_get_IoResourceDescriptor(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Cache(VARIANT_BOOL* val)
	{
		return IIviDriverOperation_get_Cache(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Cache(VARIANT_BOOL val)
	{
		return IIviDriverOperation_put_Cache(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_InterchangeCheck(VARIANT_BOOL* val)
	{
		return IIviDriverOperation_get_InterchangeCheck(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_InterchangeCheck(VARIANT_BOOL val)
	{
		return IIviDriverOperation_put_InterchangeCheck(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_QueryInstrumentStatus(VARIANT_BOOL* val)
	{
		return IIviDriverOperation_get_QueryInstrumentStatus(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_QueryInstrumentStatus(VARIANT_BOOL val)
	{
		return IIviDriverOperation_put_QueryInstrumentStatus(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_RangeCheck(VARIANT_BOOL* val)
	{
		return IIviDriverOperation_get_RangeCheck(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_RangeCheck(VARIANT_BOOL val)
	{
		return IIviDriverOperation_put_RangeCheck(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_RecordCoercions(VARIANT_BOOL* val)
	{
		return IIviDriverOperation_get_RecordCoercions(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_RecordCoercions(VARIANT_BOOL val)
	{
		return IIviDriverOperation_put_RecordCoercions(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Simulate(VARIANT_BOOL* val)
	{
		return IIviDriverOperation_get_Simulate(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Simulate(VARIANT_BOOL val)
	{
		return IIviDriverOperation_put_Simulate(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DriverSetup(BSTR* val)
	{
		return IIviDriverOperation_get_DriverSetup(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDriverOperation<Agilent34980A> _IIviDriverOperation;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDriverIdentity
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDriverIdentity : public IIviDriverIdentity
{
	STDMETHODIMP get_Description(BSTR* val)
	{
		return IIviComponentIdentity_get_Description(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Revision(BSTR* val)
	{
		return IIviComponentIdentity_get_Revision(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Vendor(BSTR* val)
	{
		return IIviComponentIdentity_get_Vendor(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_InstrumentManufacturer(BSTR* val)
	{
		return IIviDriverIdentity_get_InstrumentManufacturer(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_InstrumentModel(BSTR* val)
	{
		return IIviDriverIdentity_get_InstrumentModel(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_InstrumentFirmwareRevision(BSTR* val)
	{
		return IIviDriverIdentity_get_InstrumentFirmwareRevision(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Identifier(BSTR* val)
	{
		return IIviDriverIdentity_get_Identifier(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SupportedInstrumentModels(BSTR* val)
	{
		return IIviDriverIdentity_get_SupportedInstrumentModels(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SpecificationMajorVersion(long* val)
	{
		return IIviDriverIdentity_get_SpecificationMajorVersion(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SpecificationMinorVersion(long* val)
	{
		return IIviDriverIdentity_get_SpecificationMinorVersion(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_GroupCapabilities(BSTR* val)
	{
		return IIviDriverIdentity_get_GroupCapabilities(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviDriverIdentity<Agilent34980A> _IIviDriverIdentity;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviComponentIdentity
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviComponentIdentity : public IIviComponentIdentity
{
	STDMETHODIMP get_Description(BSTR* val)
	{
		return IIviComponentIdentity_get_Description(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Revision(BSTR* val)
	{
		return IIviComponentIdentity_get_Revision(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Vendor(BSTR* val)
	{
		return IIviComponentIdentity_get_Vendor(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviComponentIdentity<Agilent34980A> _IIviComponentIdentity;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviDriverUtility
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviDriverUtility : public IIviDriverUtility
{
	STDMETHODIMP UnlockObject()
	{
		return IIviDriverUtility_UnlockObject(static_cast<Deriving*>(this));
	}
	STDMETHODIMP LockObject()
	{
		return IIviDriverUtility_LockObject(static_cast<Deriving*>(this));
	}
	STDMETHODIMP ErrorQuery(long* ErrorCode, BSTR* ErrorMessage)
	{
		return IIviDriverUtility_ErrorQuery(static_cast<Deriving*>(this), ErrorCode, ErrorMessage);
	}
	STDMETHODIMP SelfTest(long* TestResult, BSTR* TestMessage)
	{
		return IIviDriverUtility_SelfTest(static_cast<Deriving*>(this), TestResult, TestMessage);
	}
	STDMETHODIMP Disable()
	{
		return IIviDriverUtility_Disable(static_cast<Deriving*>(this));
	}
	STDMETHODIMP ResetWithDefaults()
	{
		return IIviDriverUtility_ResetWithDefaults(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Reset()
	{
		return IIviDriverUtility_Reset(static_cast<Deriving*>(this));
	}
};

typedef __IIviDriverUtility<Agilent34980A> _IIviDriverUtility;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AAlarm
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AAlarm : public IAgilent34980AAlarm
{
	STDMETHODIMP Clear(VARIANT_BOOL ClearAll, long Index)
	{
		return IAgilent34980AAlarm_Clear(static_cast<Deriving*>(this), ClearAll, Index);
	}
	STDMETHODIMP AlarmScanSetup(BSTR ChannelList, long Channel, long AlarmIndex, long NumSweeps, double UpperLimit)
	{
		return IAgilent34980AAlarm_AlarmScanSetup(static_cast<Deriving*>(this), ChannelList, Channel, AlarmIndex, NumSweeps, UpperLimit);
	}
	STDMETHODIMP get_LowerLimit(BSTR ChannelList, double* val)
	{
		return IAgilent34980AAlarm_get_LowerLimit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_LowerLimit(BSTR ChannelList, double val)
	{
		return IAgilent34980AAlarm_put_LowerLimit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_LowerLimitEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AAlarm_get_LowerLimitEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_LowerLimitEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AAlarm_put_LowerLimitEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Mode(Agilent34980AAlarmModeEnum* val)
	{
		return IAgilent34980AAlarm_get_Mode(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Mode(Agilent34980AAlarmModeEnum val)
	{
		return IAgilent34980AAlarm_put_Mode(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_QueryAlarmQueue(BSTR* val)
	{
		return IAgilent34980AAlarm_get_QueryAlarmQueue(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Slope(Agilent34980ASlopeEnum* val)
	{
		return IAgilent34980AAlarm_get_Slope(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Slope(Agilent34980ASlopeEnum val)
	{
		return IAgilent34980AAlarm_put_Slope(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Source(long Index, BSTR* val)
	{
		return IAgilent34980AAlarm_get_Source(static_cast<Deriving*>(this), Index, val);
	}
	STDMETHODIMP put_Source(long Index, BSTR val)
	{
		return IAgilent34980AAlarm_put_Source(static_cast<Deriving*>(this), Index, val);
	}
	STDMETHODIMP get_UpperLimit(BSTR ChannelList, double* val)
	{
		return IAgilent34980AAlarm_get_UpperLimit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_UpperLimit(BSTR ChannelList, double val)
	{
		return IAgilent34980AAlarm_put_UpperLimit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_UpperLimitEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AAlarm_get_UpperLimitEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_UpperLimitEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AAlarm_put_UpperLimitEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AAlarm<Agilent34980A> _IAgilent34980AAlarm;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AACVoltage
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AACVoltage : public IAgilent34980AACVoltage
{
	STDMETHODIMP Configure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
	{
		return IAgilent34980AACVoltage_Configure(static_cast<Deriving*>(this), ChannelList, Range, Resolution);
	}
	STDMETHODIMP Measure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980AACVoltage_Measure(static_cast<Deriving*>(this), ChannelList, Range, Resolution, val);
	}
	STDMETHODIMP get_AutoRange(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AACVoltage_get_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoRange(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AACVoltage_put_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Bandwidth(BSTR ChannelList, double* val)
	{
		return IAgilent34980AACVoltage_get_Bandwidth(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Bandwidth(BSTR ChannelList, double val)
	{
		return IAgilent34980AACVoltage_put_Bandwidth(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Range(BSTR ChannelList, double* val)
	{
		return IAgilent34980AACVoltage_get_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Range(BSTR ChannelList, double val)
	{
		return IAgilent34980AACVoltage_put_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AACVoltage<Agilent34980A> _IAgilent34980AACVoltage;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AACCurrent
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AACCurrent : public IAgilent34980AACCurrent
{
	STDMETHODIMP Configure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
	{
		return IAgilent34980AACCurrent_Configure(static_cast<Deriving*>(this), ChannelList, Range, Resolution);
	}
	STDMETHODIMP Measure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980AACCurrent_Measure(static_cast<Deriving*>(this), ChannelList, Range, Resolution, val);
	}
	STDMETHODIMP get_AutoRange(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AACCurrent_get_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoRange(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AACCurrent_put_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Bandwidth(BSTR ChannelList, double* val)
	{
		return IAgilent34980AACCurrent_get_Bandwidth(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Bandwidth(BSTR ChannelList, double val)
	{
		return IAgilent34980AACCurrent_put_Bandwidth(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Range(BSTR ChannelList, double* val)
	{
		return IAgilent34980AACCurrent_get_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Range(BSTR ChannelList, double val)
	{
		return IAgilent34980AACCurrent_put_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AACCurrent<Agilent34980A> _IAgilent34980AACCurrent;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ACalibration
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ACalibration : public IAgilent34980ACalibration
{
	STDMETHODIMP SecurityEnable(VARIANT_BOOL Enable, BSTR Code)
	{
		return IAgilent34980ACalibration_SecurityEnable(static_cast<Deriving*>(this), Enable, Code);
	}
	STDMETHODIMP put_Code(BSTR val)
	{
		return IAgilent34980ACalibration_put_Code(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_String(BSTR* val)
	{
		return IAgilent34980ACalibration_get_String(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_String(BSTR val)
	{
		return IAgilent34980ACalibration_put_String(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Count(long* val)
	{
		return IAgilent34980ACalibration_get_Count(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_LineFrequency(double* val)
	{
		return IAgilent34980ACalibration_get_LineFrequency(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_LineFrequency(double val)
	{
		return IAgilent34980ACalibration_put_LineFrequency(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SecurityState(VARIANT_BOOL* val)
	{
		return IAgilent34980ACalibration_get_SecurityState(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DAC(IAgilent34980ADAC** val)
	{
		return IAgilent34980ACalibration_get_DAC(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DMM(IAgilent34980ADMM** val)
	{
		return IAgilent34980ACalibration_get_DMM(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980ACalibration<Agilent34980A> _IAgilent34980ACalibration;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ACurrent
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ACurrent : public IAgilent34980ACurrent
{
	STDMETHODIMP get_ACCurrent(IAgilent34980AACCurrent** val)
	{
		return IAgilent34980ACurrent_get_ACCurrent(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DCCurrent(IAgilent34980ADCCurrent** val)
	{
		return IAgilent34980ACurrent_get_DCCurrent(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980ACurrent<Agilent34980A> _IAgilent34980ACurrent;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ADCCurrent
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ADCCurrent : public IAgilent34980ADCCurrent
{
	STDMETHODIMP Configure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
	{
		return IAgilent34980ADCCurrent_Configure(static_cast<Deriving*>(this), ChannelList, Range, Resolution);
	}
	STDMETHODIMP Measure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980ADCCurrent_Measure(static_cast<Deriving*>(this), ChannelList, Range, Resolution, val);
	}
	STDMETHODIMP get_Aperture(BSTR ChannelList, double* val)
	{
		return IAgilent34980ADCCurrent_get_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Aperture(BSTR ChannelList, double val)
	{
		return IAgilent34980ADCCurrent_put_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoRange(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ADCCurrent_get_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoRange(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ADCCurrent_put_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_NPLC(BSTR ChannelList, double* val)
	{
		return IAgilent34980ADCCurrent_get_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_NPLC(BSTR ChannelList, double val)
	{
		return IAgilent34980ADCCurrent_put_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Range(BSTR ChannelList, double* val)
	{
		return IAgilent34980ADCCurrent_get_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Range(BSTR ChannelList, double val)
	{
		return IAgilent34980ADCCurrent_put_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Resolution(BSTR ChannelList, double* val)
	{
		return IAgilent34980ADCCurrent_get_Resolution(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum* val)
	{
		return IAgilent34980ADCCurrent_get_AutoZero(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum val)
	{
		return IAgilent34980ADCCurrent_put_AutoZero(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980ADCCurrent<Agilent34980A> _IAgilent34980ADCCurrent;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ADCVoltage
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ADCVoltage : public IAgilent34980ADCVoltage
{
	STDMETHODIMP Configure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
	{
		return IAgilent34980ADCVoltage_Configure(static_cast<Deriving*>(this), ChannelList, Range, Resolution);
	}
	STDMETHODIMP Measure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980ADCVoltage_Measure(static_cast<Deriving*>(this), ChannelList, Range, Resolution, val);
	}
	STDMETHODIMP get_Aperture(BSTR ChannelList, double* val)
	{
		return IAgilent34980ADCVoltage_get_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Aperture(BSTR ChannelList, double val)
	{
		return IAgilent34980ADCVoltage_put_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoRange(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ADCVoltage_get_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoRange(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ADCVoltage_put_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_NPLC(BSTR ChannelList, double* val)
	{
		return IAgilent34980ADCVoltage_get_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_NPLC(BSTR ChannelList, double val)
	{
		return IAgilent34980ADCVoltage_put_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Range(BSTR ChannelList, double* val)
	{
		return IAgilent34980ADCVoltage_get_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Range(BSTR ChannelList, double val)
	{
		return IAgilent34980ADCVoltage_put_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Resolution(BSTR ChannelList, double* val)
	{
		return IAgilent34980ADCVoltage_get_Resolution(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum* val)
	{
		return IAgilent34980ADCVoltage_get_AutoZero(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum val)
	{
		return IAgilent34980ADCVoltage_put_AutoZero(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoImpedance(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ADCVoltage_get_AutoImpedance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoImpedance(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ADCVoltage_put_AutoImpedance(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980ADCVoltage<Agilent34980A> _IAgilent34980ADCVoltage;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ADiagnostic
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ADiagnostic : public IAgilent34980ADiagnostic
{
	STDMETHODIMP RelayCyclesClear(BSTR ChannelList)
	{
		return IAgilent34980ADiagnostic_RelayCyclesClear(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP DMMCyclesClear(long Index)
	{
		return IAgilent34980ADiagnostic_DMMCyclesClear(static_cast<Deriving*>(this), Index);
	}
	STDMETHODIMP get_DMMCycles(long Index, long* val)
	{
		return IAgilent34980ADiagnostic_get_DMMCycles(static_cast<Deriving*>(this), Index, val);
	}
	STDMETHODIMP get_RelayCycles(BSTR ChannelList, long* val)
	{
		return IAgilent34980ADiagnostic_get_RelayCycles(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980ADiagnostic<Agilent34980A> _IAgilent34980ADiagnostic;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ADisplay
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ADisplay : public IAgilent34980ADisplay
{
	STDMETHODIMP ClearDisplay()
	{
		return IAgilent34980ADisplay_ClearDisplay(static_cast<Deriving*>(this));
	}
	STDMETHODIMP MonitorDMM()
	{
		return IAgilent34980ADisplay_MonitorDMM(static_cast<Deriving*>(this));
	}
	STDMETHODIMP MonitorChannel(BSTR Channel)
	{
		return IAgilent34980ADisplay_MonitorChannel(static_cast<Deriving*>(this), Channel);
	}
	STDMETHODIMP get_DisplayEnabled(VARIANT_BOOL* val)
	{
		return IAgilent34980ADisplay_get_DisplayEnabled(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_DisplayEnabled(VARIANT_BOOL val)
	{
		return IAgilent34980ADisplay_put_DisplayEnabled(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DisplayText(BSTR* val)
	{
		return IAgilent34980ADisplay_get_DisplayText(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_DisplayText(BSTR val)
	{
		return IAgilent34980ADisplay_put_DisplayText(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_MonitorData(double* val)
	{
		return IAgilent34980ADisplay_get_MonitorData(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_MonitorEnable(VARIANT_BOOL* val)
	{
		return IAgilent34980ADisplay_get_MonitorEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_MonitorEnable(VARIANT_BOOL val)
	{
		return IAgilent34980ADisplay_put_MonitorEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_MonitorMode(Agilent34980AMonitorModeEnum* val)
	{
		return IAgilent34980ADisplay_get_MonitorMode(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_MonitorMode(Agilent34980AMonitorModeEnum val)
	{
		return IAgilent34980ADisplay_put_MonitorMode(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_EnableMonitorChan(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ADisplay_get_EnableMonitorChan(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_EnableMonitorChan(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ADisplay_put_EnableMonitorChan(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_SelectMonitorChan(BSTR* val)
	{
		return IAgilent34980ADisplay_get_SelectMonitorChan(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_SelectMonitorChan(BSTR val)
	{
		return IAgilent34980ADisplay_put_SelectMonitorChan(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980ADisplay<Agilent34980A> _IAgilent34980ADisplay;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AFrequency
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AFrequency : public IAgilent34980AFrequency
{
	STDMETHODIMP Measure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980AFrequency_Measure(static_cast<Deriving*>(this), ChannelList, Range, Resolution, val);
	}
	STDMETHODIMP Configure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
	{
		return IAgilent34980AFrequency_Configure(static_cast<Deriving*>(this), ChannelList, Range, Resolution);
	}
	STDMETHODIMP get_Aperture(BSTR ChannelList, double* val)
	{
		return IAgilent34980AFrequency_get_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Aperture(BSTR ChannelList, double val)
	{
		return IAgilent34980AFrequency_put_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoRange(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AFrequency_get_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoRange(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AFrequency_put_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_LowRange(BSTR ChannelList, long* val)
	{
		return IAgilent34980AFrequency_get_LowRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_LowRange(BSTR ChannelList, long val)
	{
		return IAgilent34980AFrequency_put_LowRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Range(BSTR ChannelList, double* val)
	{
		return IAgilent34980AFrequency_get_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AFrequency<Agilent34980A> _IAgilent34980AFrequency;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AFResistance
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AFResistance : public IAgilent34980AFResistance
{
	STDMETHODIMP Configure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
	{
		return IAgilent34980AFResistance_Configure(static_cast<Deriving*>(this), ChannelList, Range, Resolution);
	}
	STDMETHODIMP Measure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980AFResistance_Measure(static_cast<Deriving*>(this), ChannelList, Range, Resolution, val);
	}
	STDMETHODIMP get_Aperture(BSTR ChannelList, double* val)
	{
		return IAgilent34980AFResistance_get_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Aperture(BSTR ChannelList, double val)
	{
		return IAgilent34980AFResistance_put_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoRange(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AFResistance_get_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoRange(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AFResistance_put_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_NPLC(BSTR ChannelList, double* val)
	{
		return IAgilent34980AFResistance_get_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_NPLC(BSTR ChannelList, double val)
	{
		return IAgilent34980AFResistance_put_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_OCompensated(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AFResistance_get_OCompensated(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_OCompensated(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AFResistance_put_OCompensated(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Range(BSTR ChannelList, double* val)
	{
		return IAgilent34980AFResistance_get_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Range(BSTR ChannelList, double val)
	{
		return IAgilent34980AFResistance_put_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Resolution(BSTR ChannelList, double* val)
	{
		return IAgilent34980AFResistance_get_Resolution(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AFResistance<Agilent34980A> _IAgilent34980AFResistance;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AMeasurement
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AMeasurement : public IAgilent34980AMeasurement
{
	STDMETHODIMP Initiate()
	{
		return IAgilent34980AMeasurement_Initiate(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Abort()
	{
		return IAgilent34980AMeasurement_Abort(static_cast<Deriving*>(this));
	}
	STDMETHODIMP DestructiveRead(long MaxCount, SAFEARRAY** val)
	{
		return IAgilent34980AMeasurement_DestructiveRead(static_cast<Deriving*>(this), MaxCount, val);
	}
	STDMETHODIMP Fetch(SAFEARRAY** val)
	{
		return IAgilent34980AMeasurement_Fetch(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP FetchNumbersOnly(SAFEARRAY** val)
	{
		return IAgilent34980AMeasurement_FetchNumbersOnly(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP QueryLast(BSTR Channel, double* val)
	{
		return IAgilent34980AMeasurement_QueryLast(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP Read(BSTR ChannelList, SAFEARRAY** val)
	{
		return IAgilent34980AMeasurement_Read(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP ReadNumbersOnly(BSTR ChannelList, SAFEARRAY** val)
	{
		return IAgilent34980AMeasurement_ReadNumbersOnly(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP RemoveReadings(long NumReadings, SAFEARRAY** val)
	{
		return IAgilent34980AMeasurement_RemoveReadings(static_cast<Deriving*>(this), NumReadings, val);
	}
	STDMETHODIMP SendSoftwareTrigger()
	{
		return IAgilent34980AMeasurement_SendSoftwareTrigger(static_cast<Deriving*>(this));
	}
	STDMETHODIMP get_DataFormat(IAgilent34980ADataFormat** val)
	{
		return IAgilent34980AMeasurement_get_DataFormat(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ReadingCount(long* val)
	{
		return IAgilent34980AMeasurement_get_ReadingCount(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_MeasurementFunction(BSTR Channel, BSTR* val)
	{
		return IAgilent34980AMeasurement_get_MeasurementFunction(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP put_MeasurementFunction(BSTR Channel, BSTR val)
	{
		return IAgilent34980AMeasurement_put_MeasurementFunction(static_cast<Deriving*>(this), Channel, val);
	}
};

typedef __IAgilent34980AMeasurement<Agilent34980A> _IAgilent34980AMeasurement;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AMemory
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AMemory : public IAgilent34980AMemory
{
	STDMETHODIMP SaveState(BSTR Identifier)
	{
		return IAgilent34980AMemory_SaveState(static_cast<Deriving*>(this), Identifier);
	}
	STDMETHODIMP RecallState(BSTR Identifier)
	{
		return IAgilent34980AMemory_RecallState(static_cast<Deriving*>(this), Identifier);
	}
	STDMETHODIMP DeleteLocation(long LocationNum, VARIANT_BOOL DeleteAll)
	{
		return IAgilent34980AMemory_DeleteLocation(static_cast<Deriving*>(this), LocationNum, DeleteAll);
	}
	STDMETHODIMP get_AutoRecall(VARIANT_BOOL* val)
	{
		return IAgilent34980AMemory_get_AutoRecall(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_AutoRecall(VARIANT_BOOL val)
	{
		return IAgilent34980AMemory_put_AutoRecall(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_NumStates(long* val)
	{
		return IAgilent34980AMemory_get_NumStates(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_StateName(long LocationNum, BSTR* val)
	{
		return IAgilent34980AMemory_get_StateName(static_cast<Deriving*>(this), LocationNum, val);
	}
	STDMETHODIMP put_StateName(long LocationNum, BSTR val)
	{
		return IAgilent34980AMemory_put_StateName(static_cast<Deriving*>(this), LocationNum, val);
	}
	STDMETHODIMP get_ValidState(long LocationNum, VARIANT_BOOL* val)
	{
		return IAgilent34980AMemory_get_ValidState(static_cast<Deriving*>(this), LocationNum, val);
	}
	STDMETHODIMP get_Catalog(BSTR* val)
	{
		return IAgilent34980AMemory_get_Catalog(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980AMemory<Agilent34980A> _IAgilent34980AMemory;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980APeriod
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980APeriod : public IAgilent34980APeriod
{
	STDMETHODIMP Configure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
	{
		return IAgilent34980APeriod_Configure(static_cast<Deriving*>(this), ChannelList, Range, Resolution);
	}
	STDMETHODIMP Measure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980APeriod_Measure(static_cast<Deriving*>(this), ChannelList, Range, Resolution, val);
	}
	STDMETHODIMP get_Aperture(BSTR ChannelList, double* val)
	{
		return IAgilent34980APeriod_get_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Aperture(BSTR ChannelList, double val)
	{
		return IAgilent34980APeriod_put_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoRange(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980APeriod_get_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoRange(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980APeriod_put_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Range(BSTR ChannelList, double* val)
	{
		return IAgilent34980APeriod_get_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980APeriod<Agilent34980A> _IAgilent34980APeriod;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AResistance
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AResistance : public IAgilent34980AResistance
{
	STDMETHODIMP Configure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
	{
		return IAgilent34980AResistance_Configure(static_cast<Deriving*>(this), ChannelList, Range, Resolution);
	}
	STDMETHODIMP Measure(BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980AResistance_Measure(static_cast<Deriving*>(this), ChannelList, Range, Resolution, val);
	}
	STDMETHODIMP get_Aperture(BSTR ChannelList, double* val)
	{
		return IAgilent34980AResistance_get_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Aperture(BSTR ChannelList, double val)
	{
		return IAgilent34980AResistance_put_Aperture(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoRange(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AResistance_get_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoRange(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AResistance_put_AutoRange(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_NPLC(BSTR ChannelList, double* val)
	{
		return IAgilent34980AResistance_get_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_NPLC(BSTR ChannelList, double val)
	{
		return IAgilent34980AResistance_put_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_OCompensated(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AResistance_get_OCompensated(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_OCompensated(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AResistance_put_OCompensated(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Range(BSTR ChannelList, double* val)
	{
		return IAgilent34980AResistance_get_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Range(BSTR ChannelList, double val)
	{
		return IAgilent34980AResistance_put_Range(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Resolution(BSTR ChannelList, double* val)
	{
		return IAgilent34980AResistance_get_Resolution(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum* val)
	{
		return IAgilent34980AResistance_get_AutoZero(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum val)
	{
		return IAgilent34980AResistance_put_AutoZero(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AResistance<Agilent34980A> _IAgilent34980AResistance;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AScale
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AScale : public IAgilent34980AScale
{
	STDMETHODIMP OffsetNull(BSTR ChannelList)
	{
		return IAgilent34980AScale_OffsetNull(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP get_Gain(BSTR ChannelList, double* val)
	{
		return IAgilent34980AScale_get_Gain(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Gain(BSTR ChannelList, double val)
	{
		return IAgilent34980AScale_put_Gain(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Offset(BSTR ChannelList, double* val)
	{
		return IAgilent34980AScale_get_Offset(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Offset(BSTR ChannelList, double val)
	{
		return IAgilent34980AScale_put_Offset(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_State(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AScale_get_State(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_State(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AScale_put_State(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Unit(BSTR ChannelList, BSTR* val)
	{
		return IAgilent34980AScale_get_Unit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Unit(BSTR ChannelList, BSTR val)
	{
		return IAgilent34980AScale_put_Unit(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AScale<Agilent34980A> _IAgilent34980AScale;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ARoute
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ARoute : public IAgilent34980ARoute
{
	STDMETHODIMP CloseExclusive(BSTR ChannelList)
	{
		return IAgilent34980ARoute_CloseExclusive(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Close(BSTR ChannelList)
	{
		return IAgilent34980ARoute_Close(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Open(BSTR ChannelList)
	{
		return IAgilent34980ARoute_Open(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP OpenAll(long Slot)
	{
		return IAgilent34980ARoute_OpenAll(static_cast<Deriving*>(this), Slot);
	}
	STDMETHODIMP get_AutoDelay(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ARoute_get_AutoDelay(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoDelay(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ARoute_put_AutoDelay(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Delay(BSTR ChannelList, double* val)
	{
		return IAgilent34980ARoute_get_Delay(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Delay(BSTR ChannelList, double val)
	{
		return IAgilent34980ARoute_put_Delay(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_FWire(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ARoute_get_FWire(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_FWire(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ARoute_put_FWire(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Done(VARIANT_BOOL* val)
	{
		return IAgilent34980ARoute_get_Done(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_IsClosed(BSTR Channel, VARIANT_BOOL* val)
	{
		return IAgilent34980ARoute_get_IsClosed(static_cast<Deriving*>(this), Channel, val);
	}
};

typedef __IAgilent34980ARoute<Agilent34980A> _IAgilent34980ARoute;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AScan
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AScan : public IAgilent34980AScan
{
	STDMETHODIMP ConfigureScan(BSTR ChannelList, long SweepCount, VARIANT_BOOL Ordered)
	{
		return IAgilent34980AScan_ConfigureScan(static_cast<Deriving*>(this), ChannelList, SweepCount, Ordered);
	}
	STDMETHODIMP get_ScanSize(long* val)
	{
		return IAgilent34980AScan_get_ScanSize(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ScanList(BSTR* val)
	{
		return IAgilent34980AScan_get_ScanList(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_ScanList(BSTR val)
	{
		return IAgilent34980AScan_put_ScanList(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ScanTime(BSTR* val)
	{
		return IAgilent34980AScan_get_ScanTime(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SweepCount(long* val)
	{
		return IAgilent34980AScan_get_SweepCount(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_SweepCount(long val)
	{
		return IAgilent34980AScan_put_SweepCount(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_OrderedScan(VARIANT_BOOL* val)
	{
		return IAgilent34980AScan_get_OrderedScan(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_OrderedScan(VARIANT_BOOL val)
	{
		return IAgilent34980AScan_put_OrderedScan(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980AScan<Agilent34980A> _IAgilent34980AScan;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AStatistics
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AStatistics : public IAgilent34980AStatistics
{
	STDMETHODIMP ClearStatistics(BSTR ChannelList)
	{
		return IAgilent34980AStatistics_ClearStatistics(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP get_Average(BSTR ChannelList, double* val)
	{
		return IAgilent34980AStatistics_get_Average(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Count(BSTR ChannelList, long* val)
	{
		return IAgilent34980AStatistics_get_Count(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_MaxValue(BSTR ChannelList, double* val)
	{
		return IAgilent34980AStatistics_get_MaxValue(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_MaxValueTime(BSTR ChannelList, BSTR* val)
	{
		return IAgilent34980AStatistics_get_MaxValueTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_MinValue(BSTR ChannelList, double* val)
	{
		return IAgilent34980AStatistics_get_MinValue(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_MinValueTime(BSTR ChannelList, BSTR* val)
	{
		return IAgilent34980AStatistics_get_MinValueTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_PTPeak(BSTR ChannelList, double* val)
	{
		return IAgilent34980AStatistics_get_PTPeak(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AStatistics<Agilent34980A> _IAgilent34980AStatistics;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AStatus
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AStatus : public IAgilent34980AStatus
{
	STDMETHODIMP Preset()
	{
		return IAgilent34980AStatus_Preset(static_cast<Deriving*>(this));
	}
	STDMETHODIMP ConfigureServiceRequest(Agilent34980ASRQReasonEnum Reason)
	{
		return IAgilent34980AStatus_ConfigureServiceRequest(static_cast<Deriving*>(this), Reason);
	}
	STDMETHODIMP Clear()
	{
		return IAgilent34980AStatus_Clear(static_cast<Deriving*>(this));
	}
	STDMETHODIMP get_Register(Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long* val)
	{
		return IAgilent34980AStatus_get_Register(static_cast<Deriving*>(this), Register, SubRegister, val);
	}
	STDMETHODIMP put_Register(Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long val)
	{
		return IAgilent34980AStatus_put_Register(static_cast<Deriving*>(this), Register, SubRegister, val);
	}
	STDMETHODIMP get_SerialPoll(long* val)
	{
		return IAgilent34980AStatus_get_SerialPoll(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980AStatus<Agilent34980A> _IAgilent34980AStatus;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ASystem
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ASystem : public IAgilent34980ASystem
{
	STDMETHODIMP WaitForOperationComplete(long MaxTimeMilliseconds)
	{
		return IAgilent34980ASystem_WaitForOperationComplete(static_cast<Deriving*>(this), MaxTimeMilliseconds);
	}
	STDMETHODIMP SetSystemTime(long Hours, long Mins, double Seconds)
	{
		return IAgilent34980ASystem_SetSystemTime(static_cast<Deriving*>(this), Hours, Mins, Seconds);
	}
	STDMETHODIMP SetSystemDate(long Year, long Month, long Day)
	{
		return IAgilent34980ASystem_SetSystemDate(static_cast<Deriving*>(this), Year, Month, Day);
	}
	STDMETHODIMP Preset()
	{
		return IAgilent34980ASystem_Preset(static_cast<Deriving*>(this));
	}
	STDMETHODIMP GetSystemTime(long* Hours, long* Mins, double* Seconds)
	{
		return IAgilent34980ASystem_GetSystemTime(static_cast<Deriving*>(this), Hours, Mins, Seconds);
	}
	STDMETHODIMP GetSystemDate(long* Year, long* Month, long* Day)
	{
		return IAgilent34980ASystem_GetSystemDate(static_cast<Deriving*>(this), Year, Month, Day);
	}
	STDMETHODIMP CardReset(long SlotNum)
	{
		return IAgilent34980ASystem_CardReset(static_cast<Deriving*>(this), SlotNum);
	}
	STDMETHODIMP LockRequest(VARIANT_BOOL* val)
	{
		return IAgilent34980ASystem_LockRequest(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP LockRelease()
	{
		return IAgilent34980ASystem_LockRelease(static_cast<Deriving*>(this));
	}
	STDMETHODIMP SecureImmediate()
	{
		return IAgilent34980ASystem_SecureImmediate(static_cast<Deriving*>(this));
	}
	STDMETHODIMP GetModuleTemperature(Agilent34980AModuleTemperatureEnum Mode, long Slot, double* val)
	{
		return IAgilent34980ASystem_GetModuleTemperature(static_cast<Deriving*>(this), Mode, Slot, val);
	}
	STDMETHODIMP get_AsyncEventsEnabled(VARIANT_BOOL* val)
	{
		return IAgilent34980ASystem_get_AsyncEventsEnabled(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_AsyncEventsEnabled(VARIANT_BOOL val)
	{
		return IAgilent34980ASystem_put_AsyncEventsEnabled(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_CardType(long SlotNum, BSTR* val)
	{
		return IAgilent34980ASystem_get_CardType(static_cast<Deriving*>(this), SlotNum, val);
	}
	STDMETHODIMP get_Date(BSTR* val)
	{
		return IAgilent34980ASystem_get_Date(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Date(BSTR val)
	{
		return IAgilent34980ASystem_put_Date(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DMMEnabled(VARIANT_BOOL* val)
	{
		return IAgilent34980ASystem_get_DMMEnabled(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_DMMEnabled(VARIANT_BOOL val)
	{
		return IAgilent34980ASystem_put_DMMEnabled(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DMMInstalled(VARIANT_BOOL* val)
	{
		return IAgilent34980ASystem_get_DMMInstalled(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ReadingThreshold(long* val)
	{
		return IAgilent34980ASystem_get_ReadingThreshold(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_ReadingThreshold(long val)
	{
		return IAgilent34980ASystem_put_ReadingThreshold(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SerialNumber(BSTR* val)
	{
		return IAgilent34980ASystem_get_SerialNumber(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Time(BSTR* val)
	{
		return IAgilent34980ASystem_get_Time(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Time(BSTR val)
	{
		return IAgilent34980ASystem_put_Time(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_TimeoutMilliseconds(long* val)
	{
		return IAgilent34980ASystem_get_TimeoutMilliseconds(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_TimeoutMilliseconds(long val)
	{
		return IAgilent34980ASystem_put_TimeoutMilliseconds(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_IO(IFormattedIO488** val)
	{
		return IAgilent34980ASystem_get_IO(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_EnableInterface(Agilent34980AHWInterfaceEnum HWInterface, VARIANT_BOOL* val)
	{
		return IAgilent34980ASystem_get_EnableInterface(static_cast<Deriving*>(this), HWInterface, val);
	}
	STDMETHODIMP put_EnableInterface(Agilent34980AHWInterfaceEnum HWInterface, VARIANT_BOOL val)
	{
		return IAgilent34980ASystem_put_EnableInterface(static_cast<Deriving*>(this), HWInterface, val);
	}
	STDMETHODIMP get_LockOwner(BSTR* val)
	{
		return IAgilent34980ASystem_get_LockOwner(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_ModuleWireMode(long SlotNumber, Agilent34980AWireModeEnum val)
	{
		return IAgilent34980ASystem_put_ModuleWireMode(static_cast<Deriving*>(this), SlotNumber, val);
	}
	STDMETHODIMP get_ModuleEvents(BSTR* val)
	{
		return IAgilent34980ASystem_get_ModuleEvents(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980ASystem<Agilent34980A> _IAgilent34980ASystem;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ATemperature
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ATemperature : public IAgilent34980ATemperature
{
	STDMETHODIMP get_ReadingUnits(BSTR ChannelList, Agilent34980ATemperatureUnitsEnum* val)
	{
		return IAgilent34980ATemperature_get_ReadingUnits(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ReadingUnits(BSTR ChannelList, Agilent34980ATemperatureUnitsEnum val)
	{
		return IAgilent34980ATemperature_put_ReadingUnits(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_FRTD(IAgilent34980AFRTD** val)
	{
		return IAgilent34980ATemperature_get_FRTD(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_RTD(IAgilent34980ARTD** val)
	{
		return IAgilent34980ATemperature_get_RTD(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Thermocouple(IAgilent34980AThermocouple** val)
	{
		return IAgilent34980ATemperature_get_Thermocouple(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Thermistor(IAgilent34980AThermistor** val)
	{
		return IAgilent34980ATemperature_get_Thermistor(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum* val)
	{
		return IAgilent34980ATemperature_get_AutoZero(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum val)
	{
		return IAgilent34980ATemperature_put_AutoZero(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_NPLC(BSTR ChannelList, double* val)
	{
		return IAgilent34980ATemperature_get_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_NPLC(BSTR ChannelList, double val)
	{
		return IAgilent34980ATemperature_put_NPLC(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_TransducerType(BSTR ChannelList, Agilent34980ATransducerEnum* val)
	{
		return IAgilent34980ATemperature_get_TransducerType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_TransducerType(BSTR ChannelList, Agilent34980ATransducerEnum val)
	{
		return IAgilent34980ATemperature_put_TransducerType(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980ATemperature<Agilent34980A> _IAgilent34980ATemperature;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AVoltage
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AVoltage : public IAgilent34980AVoltage
{
	STDMETHODIMP get_ACVoltage(IAgilent34980AACVoltage** val)
	{
		return IAgilent34980AVoltage_get_ACVoltage(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DCVoltage(IAgilent34980ADCVoltage** val)
	{
		return IAgilent34980AVoltage_get_DCVoltage(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980AVoltage<Agilent34980A> _IAgilent34980AVoltage;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AFRTD
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AFRTD : public IAgilent34980AFRTD
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AFRTDAlphaEnum Type)
	{
		return IAgilent34980AFRTD_Configure(static_cast<Deriving*>(this), ChannelList, Resolution, Type);
	}
	STDMETHODIMP Measure(BSTR ChannelList, Agilent34980ARTDAlphaEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980AFRTD_Measure(static_cast<Deriving*>(this), ChannelList, Type, Resolution, val);
	}
	STDMETHODIMP get_Resistance(BSTR ChannelList, double* val)
	{
		return IAgilent34980AFRTD_get_Resistance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Resistance(BSTR ChannelList, double val)
	{
		return IAgilent34980AFRTD_put_Resistance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Alpha(BSTR ChannelList, Agilent34980AFRTDAlphaEnum* val)
	{
		return IAgilent34980AFRTD_get_Alpha(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Alpha(BSTR ChannelList, Agilent34980AFRTDAlphaEnum val)
	{
		return IAgilent34980AFRTD_put_Alpha(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_IsExternalReference(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AFRTD_get_IsExternalReference(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_IsExternalReference(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AFRTD_put_IsExternalReference(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_OCompensated(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AFRTD_get_OCompensated(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_OCompensated(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AFRTD_put_OCompensated(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AFRTD<Agilent34980A> _IAgilent34980AFRTD;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ADataFormat
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ADataFormat : public IAgilent34980ADataFormat
{
	STDMETHODIMP Configure(VARIANT_BOOL EnableAlarm, VARIANT_BOOL EnableChannel, VARIANT_BOOL EnableTime, Agilent34980ATimeOffsetEnum TimeType, VARIANT_BOOL EnableUnit)
	{
		return IAgilent34980ADataFormat_Configure(static_cast<Deriving*>(this), EnableAlarm, EnableChannel, EnableTime, TimeType, EnableUnit);
	}
	STDMETHODIMP get_AlarmEnable(VARIANT_BOOL* val)
	{
		return IAgilent34980ADataFormat_get_AlarmEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_AlarmEnable(VARIANT_BOOL val)
	{
		return IAgilent34980ADataFormat_put_AlarmEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ChannelEnable(VARIANT_BOOL* val)
	{
		return IAgilent34980ADataFormat_get_ChannelEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_ChannelEnable(VARIANT_BOOL val)
	{
		return IAgilent34980ADataFormat_put_ChannelEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_TimeEnable(VARIANT_BOOL* val)
	{
		return IAgilent34980ADataFormat_get_TimeEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_TimeEnable(VARIANT_BOOL val)
	{
		return IAgilent34980ADataFormat_put_TimeEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_TimeType(Agilent34980ATimeOffsetEnum* val)
	{
		return IAgilent34980ADataFormat_get_TimeType(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_TimeType(Agilent34980ATimeOffsetEnum val)
	{
		return IAgilent34980ADataFormat_put_TimeType(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_UnitEnable(VARIANT_BOOL* val)
	{
		return IAgilent34980ADataFormat_get_UnitEnable(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_UnitEnable(VARIANT_BOOL val)
	{
		return IAgilent34980ADataFormat_put_UnitEnable(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980ADataFormat<Agilent34980A> _IAgilent34980ADataFormat;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ARTD
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ARTD : public IAgilent34980ARTD
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980ARTDAlphaEnum Type)
	{
		return IAgilent34980ARTD_Configure(static_cast<Deriving*>(this), ChannelList, Resolution, Type);
	}
	STDMETHODIMP Measure(BSTR ChannelList, Agilent34980ARTDAlphaEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980ARTD_Measure(static_cast<Deriving*>(this), ChannelList, Type, Resolution, val);
	}
	STDMETHODIMP get_Resistance(BSTR ChannelList, double* val)
	{
		return IAgilent34980ARTD_get_Resistance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Resistance(BSTR ChannelList, double val)
	{
		return IAgilent34980ARTD_put_Resistance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Alpha(BSTR ChannelList, Agilent34980ARTDAlphaEnum* val)
	{
		return IAgilent34980ARTD_get_Alpha(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Alpha(BSTR ChannelList, Agilent34980ARTDAlphaEnum val)
	{
		return IAgilent34980ARTD_put_Alpha(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_IsExternalReference(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ARTD_get_IsExternalReference(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_IsExternalReference(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ARTD_put_IsExternalReference(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_OCompensated(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ARTD_get_OCompensated(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_OCompensated(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ARTD_put_OCompensated(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980ARTD<Agilent34980A> _IAgilent34980ARTD;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AThermistor
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AThermistor : public IAgilent34980AThermistor
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AThermistorEnum Type)
	{
		return IAgilent34980AThermistor_Configure(static_cast<Deriving*>(this), ChannelList, Resolution, Type);
	}
	STDMETHODIMP Measure(BSTR ChannelList, Agilent34980AThermistorEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980AThermistor_Measure(static_cast<Deriving*>(this), ChannelList, Type, Resolution, val);
	}
	STDMETHODIMP get_Resistance(BSTR ChannelList, Agilent34980AThermistorEnum* val)
	{
		return IAgilent34980AThermistor_get_Resistance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Resistance(BSTR ChannelList, Agilent34980AThermistorEnum val)
	{
		return IAgilent34980AThermistor_put_Resistance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_IsExternalReference(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AThermistor_get_IsExternalReference(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_IsExternalReference(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AThermistor_put_IsExternalReference(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AThermistor<Agilent34980A> _IAgilent34980AThermistor;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AThermocouple
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AThermocouple : public IAgilent34980AThermocouple
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AThermocoupleEnum Type)
	{
		return IAgilent34980AThermocouple_Configure(static_cast<Deriving*>(this), ChannelList, Resolution, Type);
	}
	STDMETHODIMP Measure(BSTR ChannelList, Agilent34980AThermocoupleEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
	{
		return IAgilent34980AThermocouple_Measure(static_cast<Deriving*>(this), ChannelList, Type, Resolution, val);
	}
	STDMETHODIMP get_ThermocoupleType(BSTR ChannelList, Agilent34980AThermocoupleEnum* val)
	{
		return IAgilent34980AThermocouple_get_ThermocoupleType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ThermocoupleType(BSTR ChannelList, Agilent34980AThermocoupleEnum val)
	{
		return IAgilent34980AThermocouple_put_ThermocoupleType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ReferenceJunctionType(BSTR ChannelList, Agilent34980ARJunctionEnum* val)
	{
		return IAgilent34980AThermocouple_get_ReferenceJunctionType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ReferenceJunctionType(BSTR ChannelList, Agilent34980ARJunctionEnum val)
	{
		return IAgilent34980AThermocouple_put_ReferenceJunctionType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_FixedReferenceJunction(BSTR ChannelList, double* val)
	{
		return IAgilent34980AThermocouple_get_FixedReferenceJunction(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_FixedReferenceJunction(BSTR ChannelList, double val)
	{
		return IAgilent34980AThermocouple_put_FixedReferenceJunction(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Check(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AThermocouple_get_Check(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Check(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AThermocouple_put_Check(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AutoImpedance(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AThermocouple_get_AutoImpedance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoImpedance(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AThermocouple_put_AutoImpedance(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ExternalReferenceJunction(double* val)
	{
		return IAgilent34980AThermocouple_get_ExternalReferenceJunction(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_InternalReferenceJunction(BSTR ChannelList, double* val)
	{
		return IAgilent34980AThermocouple_get_InternalReferenceJunction(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34980AThermocouple<Agilent34980A> _IAgilent34980AThermocouple;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ATrigger
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ATrigger : public IAgilent34980ATrigger
{
	STDMETHODIMP Configure(Agilent34980ATriggerSourceEnum Source, long TriggerCount, double Timer, long SampleCount)
	{
		return IAgilent34980ATrigger_Configure(static_cast<Deriving*>(this), Source, TriggerCount, Timer, SampleCount);
	}
	STDMETHODIMP get_SampleCount(long* val)
	{
		return IAgilent34980ATrigger_get_SampleCount(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_SampleCount(long val)
	{
		return IAgilent34980ATrigger_put_SampleCount(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Count(long* val)
	{
		return IAgilent34980ATrigger_get_Count(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Count(long val)
	{
		return IAgilent34980ATrigger_put_Count(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Source(Agilent34980ATriggerSourceEnum* val)
	{
		return IAgilent34980ATrigger_get_Source(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Source(Agilent34980ATriggerSourceEnum val)
	{
		return IAgilent34980ATrigger_put_Source(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Timer(double* val)
	{
		return IAgilent34980ATrigger_get_Timer(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Timer(double val)
	{
		return IAgilent34980ATrigger_put_Timer(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Delay(double* val)
	{
		return IAgilent34980ATrigger_get_Delay(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Delay(double val)
	{
		return IAgilent34980ATrigger_put_Delay(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DelayAuto(VARIANT_BOOL* val)
	{
		return IAgilent34980ATrigger_get_DelayAuto(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_DelayAuto(VARIANT_BOOL val)
	{
		return IAgilent34980ATrigger_put_DelayAuto(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980ATrigger<Agilent34980A> _IAgilent34980ATrigger;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviSwtch
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviSwtch : public IIviSwtch
{
	STDMETHODIMP Close()
	{
		return IIviDriver_Close(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Initialize(BSTR ResourceName, VARIANT_BOOL IdQuery, VARIANT_BOOL Reset, BSTR OptionString)
	{
		return IIviDriver_Initialize(static_cast<Deriving*>(this), ResourceName, IdQuery, Reset, OptionString);
	}
	STDMETHODIMP get_DriverOperation(IIviDriverOperation** val)
	{
		return IIviDriver_get_DriverOperation(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Identity(IIviDriverIdentity** val)
	{
		return IIviDriver_get_Identity(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Utility(IIviDriverUtility** val)
	{
		return IIviDriver_get_Utility(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Initialized(VARIANT_BOOL* val)
	{
		return IIviDriver_get_Initialized(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Channels(IIviSwtchChannels** val)
	{
		return IIviSwtch_get_Channels(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Path(IIviSwtchPath** val)
	{
		return IIviSwtch_get_Path(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Scan(IIviSwtchScan** val)
	{
		return IIviSwtch_get_Scan(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviSwtch<Agilent34980A> _IIviSwtch;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviSwtchChannels
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviSwtchChannels : public IIviSwtchChannels
{
	STDMETHODIMP get_Item(BSTR Name, IIviSwtchChannel** val)
	{
		return IIviSwtchChannels_get_Item(static_cast<Deriving*>(this), Name, val);
	}
	STDMETHODIMP get_Count(long* val)
	{
		return IIviSwtchChannels_get_Count(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Name(long Index, BSTR* val)
	{
		return IIviSwtchChannels_get_Name(static_cast<Deriving*>(this), Index, val);
	}
};

typedef __IIviSwtchChannels<Agilent34980A> _IIviSwtchChannels;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviSwtchPath
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviSwtchPath : public IIviSwtchPath
{
	STDMETHODIMP WaitForDebounce(long MaxTimeMilliseconds)
	{
		return IIviSwtchPath_WaitForDebounce(static_cast<Deriving*>(this), MaxTimeMilliseconds);
	}
	STDMETHODIMP SetPath(BSTR PathList)
	{
		return IIviSwtchPath_SetPath(static_cast<Deriving*>(this), PathList);
	}
	STDMETHODIMP GetPath(BSTR Channel1, BSTR Channel2, BSTR* val)
	{
		return IIviSwtchPath_GetPath(static_cast<Deriving*>(this), Channel1, Channel2, val);
	}
	STDMETHODIMP DisconnectAll()
	{
		return IIviSwtchPath_DisconnectAll(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Disconnect(BSTR Channel1, BSTR Channel2)
	{
		return IIviSwtchPath_Disconnect(static_cast<Deriving*>(this), Channel1, Channel2);
	}
	STDMETHODIMP Connect(BSTR Channel1, BSTR Channel2)
	{
		return IIviSwtchPath_Connect(static_cast<Deriving*>(this), Channel1, Channel2);
	}
	STDMETHODIMP CanConnect(BSTR Channel1, BSTR Channel2, IviSwtchPathCapabilityEnum* val)
	{
		return IIviSwtchPath_CanConnect(static_cast<Deriving*>(this), Channel1, Channel2, val);
	}
	STDMETHODIMP get_IsDebounced(VARIANT_BOOL* val)
	{
		return IIviSwtchPath_get_IsDebounced(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviSwtchPath<Agilent34980A> _IIviSwtchPath;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviSwtchScan
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviSwtchScan : public IIviSwtchScan
{
	STDMETHODIMP WaitForScanComplete(long MaxTimeMilliseconds)
	{
		return IIviSwtchScan_WaitForScanComplete(static_cast<Deriving*>(this), MaxTimeMilliseconds);
	}
	STDMETHODIMP SendSoftwareTrigger()
	{
		return IIviSwtchScan_SendSoftwareTrigger(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Abort()
	{
		return IIviSwtchScan_Abort(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Initiate()
	{
		return IIviSwtchScan_Initiate(static_cast<Deriving*>(this));
	}
	STDMETHODIMP ConfigureTrigger(double ScanDelay, IviSwtchTriggerInputEnum TriggerInput, IviSwtchAdvancedOutputEnum AdvancedOutput)
	{
		return IIviSwtchScan_ConfigureTrigger(static_cast<Deriving*>(this), ScanDelay, TriggerInput, AdvancedOutput);
	}
	STDMETHODIMP ConfigureList(BSTR List, IviSwtchScanModeEnum Mode)
	{
		return IIviSwtchScan_ConfigureList(static_cast<Deriving*>(this), List, Mode);
	}
	STDMETHODIMP get_IsScanning(VARIANT_BOOL* val)
	{
		return IIviSwtchScan_get_IsScanning(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Continuous(VARIANT_BOOL* val)
	{
		return IIviSwtchScan_get_Continuous(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Continuous(VARIANT_BOOL val)
	{
		return IIviSwtchScan_put_Continuous(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_NumberOfColumns(long* val)
	{
		return IIviSwtchScan_get_NumberOfColumns(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_NumberOfRows(long* val)
	{
		return IIviSwtchScan_get_NumberOfRows(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_AdvancedOutput(IviSwtchAdvancedOutputEnum* val)
	{
		return IIviSwtchScan_get_AdvancedOutput(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_AdvancedOutput(IviSwtchAdvancedOutputEnum val)
	{
		return IIviSwtchScan_put_AdvancedOutput(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Delay(double* val)
	{
		return IIviSwtchScan_get_Delay(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Delay(double val)
	{
		return IIviSwtchScan_put_Delay(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Input(IviSwtchTriggerInputEnum* val)
	{
		return IIviSwtchScan_get_Input(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Input(IviSwtchTriggerInputEnum val)
	{
		return IIviSwtchScan_put_Input(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_List(BSTR* val)
	{
		return IIviSwtchScan_get_List(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_List(BSTR val)
	{
		return IIviSwtchScan_put_List(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Mode(IviSwtchScanModeEnum* val)
	{
		return IIviSwtchScan_get_Mode(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Mode(IviSwtchScanModeEnum val)
	{
		return IIviSwtchScan_put_Mode(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviSwtchScan<Agilent34980A> _IIviSwtchScan;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ADMM
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ADMM : public IAgilent34980ADMM
{
	STDMETHODIMP PerformCalibration()
	{
		return IAgilent34980ADMM_PerformCalibration(static_cast<Deriving*>(this));
	}
	STDMETHODIMP get_Count(long* val)
	{
		return IAgilent34980ADMM_get_Count(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_String(BSTR* val)
	{
		return IAgilent34980ADMM_get_String(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_String(BSTR val)
	{
		return IAgilent34980ADMM_put_String(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Value(double* val)
	{
		return IAgilent34980ADMM_get_Value(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Value(double val)
	{
		return IAgilent34980ADMM_put_Value(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980ADMM<Agilent34980A> _IAgilent34980ADMM;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ADAC
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ADAC : public IAgilent34980ADAC
{
	STDMETHODIMP AutoCalibrate(short SlotNumber, VARIANT_BOOL All)
	{
		return IAgilent34980ADAC_AutoCalibrate(static_cast<Deriving*>(this), SlotNumber, All);
	}
	STDMETHODIMP Abort()
	{
		return IAgilent34980ADAC_Abort(static_cast<Deriving*>(this));
	}
	STDMETHODIMP BeginVoltageCal(BSTR ChannelList, short SetupNumber)
	{
		return IAgilent34980ADAC_BeginVoltageCal(static_cast<Deriving*>(this), ChannelList, SetupNumber);
	}
	STDMETHODIMP Point(double PointData)
	{
		return IAgilent34980ADAC_Point(static_cast<Deriving*>(this), PointData);
	}
	STDMETHODIMP get_Count(short SlotNumber, long* val)
	{
		return IAgilent34980ADAC_get_Count(static_cast<Deriving*>(this), SlotNumber, val);
	}
	STDMETHODIMP get_String(short SlotNumber, BSTR* val)
	{
		return IAgilent34980ADAC_get_String(static_cast<Deriving*>(this), SlotNumber, val);
	}
	STDMETHODIMP put_String(short SlotNumber, BSTR val)
	{
		return IAgilent34980ADAC_put_String(static_cast<Deriving*>(this), SlotNumber, val);
	}
};

typedef __IAgilent34980ADAC<Agilent34980A> _IAgilent34980ADAC;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AAlarm2
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AAlarm2 : public IAgilent34980AAlarm2
{
	STDMETHODIMP Clear(VARIANT_BOOL ClearAll, long Index)
	{
		return IAgilent34980AAlarm_Clear(static_cast<Deriving*>(this), ClearAll, Index);
	}
	STDMETHODIMP AlarmScanSetup(BSTR ChannelList, long Channel, long AlarmIndex, long NumSweeps, double UpperLimit)
	{
		return IAgilent34980AAlarm_AlarmScanSetup(static_cast<Deriving*>(this), ChannelList, Channel, AlarmIndex, NumSweeps, UpperLimit);
	}
	STDMETHODIMP get_LowerLimit(BSTR ChannelList, double* val)
	{
		return IAgilent34980AAlarm_get_LowerLimit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_LowerLimit(BSTR ChannelList, double val)
	{
		return IAgilent34980AAlarm_put_LowerLimit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_LowerLimitEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AAlarm_get_LowerLimitEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_LowerLimitEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AAlarm_put_LowerLimitEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Mode(Agilent34980AAlarmModeEnum* val)
	{
		return IAgilent34980AAlarm_get_Mode(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Mode(Agilent34980AAlarmModeEnum val)
	{
		return IAgilent34980AAlarm_put_Mode(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_QueryAlarmQueue(BSTR* val)
	{
		return IAgilent34980AAlarm_get_QueryAlarmQueue(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Slope(Agilent34980ASlopeEnum* val)
	{
		return IAgilent34980AAlarm_get_Slope(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_Slope(Agilent34980ASlopeEnum val)
	{
		return IAgilent34980AAlarm_put_Slope(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Source(long Index, BSTR* val)
	{
		return IAgilent34980AAlarm_get_Source(static_cast<Deriving*>(this), Index, val);
	}
	STDMETHODIMP put_Source(long Index, BSTR val)
	{
		return IAgilent34980AAlarm_put_Source(static_cast<Deriving*>(this), Index, val);
	}
	STDMETHODIMP get_UpperLimit(BSTR ChannelList, double* val)
	{
		return IAgilent34980AAlarm_get_UpperLimit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_UpperLimit(BSTR ChannelList, double val)
	{
		return IAgilent34980AAlarm_put_UpperLimit(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_UpperLimitEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980AAlarm_get_UpperLimitEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_UpperLimitEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980AAlarm_put_UpperLimitEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_AlarmSequence(long Index, BSTR* val)
	{
		return IAgilent34980AAlarm2_get_AlarmSequence(static_cast<Deriving*>(this), Index, val);
	}
};

typedef __IAgilent34980AAlarm2<Agilent34980A> _IAgilent34980AAlarm2;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980A2
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980A2 : public IAgilent34980A2
{
	STDMETHODIMP Close()
	{
		return IIviDriver_Close(static_cast<Deriving*>(this));
	}
	STDMETHODIMP Initialize(BSTR ResourceName, VARIANT_BOOL IdQuery, VARIANT_BOOL Reset, BSTR OptionString)
	{
		return IIviDriver_Initialize(static_cast<Deriving*>(this), ResourceName, IdQuery, Reset, OptionString);
	}
	STDMETHODIMP get_DriverOperation(IIviDriverOperation** val)
	{
		return IIviDriver_get_DriverOperation(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Identity(IIviDriverIdentity** val)
	{
		return IIviDriver_get_Identity(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Utility(IIviDriverUtility** val)
	{
		return IIviDriver_get_Utility(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Initialized(VARIANT_BOOL* val)
	{
		return IIviDriver_get_Initialized(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Alarm(IAgilent34980AAlarm2** val)
	{
		return IAgilent34980A2_get_Alarm(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Route(IAgilent34980ARoute2** val)
	{
		return IAgilent34980A2_get_Route(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Status(IAgilent34980AStatus2** val)
	{
		return IAgilent34980A2_get_Status(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Calibration(IAgilent34980ACalibration** val)
	{
		return IAgilent34980A2_get_Calibration(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Current(IAgilent34980ACurrent** val)
	{
		return IAgilent34980A2_get_Current(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Diagnostic(IAgilent34980ADiagnostic** val)
	{
		return IAgilent34980A2_get_Diagnostic(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Frequency(IAgilent34980AFrequency** val)
	{
		return IAgilent34980A2_get_Frequency(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_FResistance(IAgilent34980AFResistance** val)
	{
		return IAgilent34980A2_get_FResistance(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Measurement(IAgilent34980AMeasurement** val)
	{
		return IAgilent34980A2_get_Measurement(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Memory(IAgilent34980AMemory** val)
	{
		return IAgilent34980A2_get_Memory(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Period(IAgilent34980APeriod** val)
	{
		return IAgilent34980A2_get_Period(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Personality(IAgilent34980APersonality** val)
	{
		return IAgilent34980A2_get_Personality(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Resistance(IAgilent34980AResistance** val)
	{
		return IAgilent34980A2_get_Resistance(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Scale(IAgilent34980AScale** val)
	{
		return IAgilent34980A2_get_Scale(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Scan(IAgilent34980AScan** val)
	{
		return IAgilent34980A2_get_Scan(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Statistics(IAgilent34980AStatistics** val)
	{
		return IAgilent34980A2_get_Statistics(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_System(IAgilent34980ASystem** val)
	{
		return IAgilent34980A2_get_System(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Temperature(IAgilent34980ATemperature** val)
	{
		return IAgilent34980A2_get_Temperature(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Trigger(IAgilent34980ATrigger** val)
	{
		return IAgilent34980A2_get_Trigger(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Voltage(IAgilent34980AVoltage** val)
	{
		return IAgilent34980A2_get_Voltage(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Display(IAgilent34980ADisplay** val)
	{
		return IAgilent34980A2_get_Display(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34980A2<Agilent34980A> _IAgilent34980A2;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980ARoute2
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980ARoute2 : public IAgilent34980ARoute2
{
	STDMETHODIMP CloseExclusive(BSTR ChannelList)
	{
		return IAgilent34980ARoute_CloseExclusive(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Close(BSTR ChannelList)
	{
		return IAgilent34980ARoute_Close(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Open(BSTR ChannelList)
	{
		return IAgilent34980ARoute_Open(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP OpenAll(long Slot)
	{
		return IAgilent34980ARoute_OpenAll(static_cast<Deriving*>(this), Slot);
	}
	STDMETHODIMP get_AutoDelay(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ARoute_get_AutoDelay(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AutoDelay(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ARoute_put_AutoDelay(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Delay(BSTR ChannelList, double* val)
	{
		return IAgilent34980ARoute_get_Delay(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Delay(BSTR ChannelList, double val)
	{
		return IAgilent34980ARoute_put_Delay(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_FWire(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34980ARoute_get_FWire(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_FWire(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34980ARoute_put_FWire(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Done(VARIANT_BOOL* val)
	{
		return IAgilent34980ARoute_get_Done(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_IsClosed(BSTR Channel, VARIANT_BOOL* val)
	{
		return IAgilent34980ARoute_get_IsClosed(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP SequenceDefine(BSTR SequenceName, BSTR CommandString)
	{
		return IAgilent34980ARoute2_SequenceDefine(static_cast<Deriving*>(this), SequenceName, CommandString);
	}
	STDMETHODIMP SequenceDelete(BSTR SequenceName)
	{
		return IAgilent34980ARoute2_SequenceDelete(static_cast<Deriving*>(this), SequenceName);
	}
	STDMETHODIMP SequenceDeleteAll()
	{
		return IAgilent34980ARoute2_SequenceDeleteAll(static_cast<Deriving*>(this));
	}
	STDMETHODIMP SequenceTriggerImmediate(BSTR SequenceName)
	{
		return IAgilent34980ARoute2_SequenceTriggerImmediate(static_cast<Deriving*>(this), SequenceName);
	}
	STDMETHODIMP get_ChannelLabel(BSTR ChannelList, BSTR* val)
	{
		return IAgilent34980ARoute2_get_ChannelLabel(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ChannelLabel(BSTR ChannelList, BSTR val)
	{
		return IAgilent34980ARoute2_put_ChannelLabel(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_SequenceCatalog(BSTR* val)
	{
		return IAgilent34980ARoute2_get_SequenceCatalog(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SequenceTriggerSource(BSTR SequenceName, Agilent34980ASequenceTriggerSourceEnum* val)
	{
		return IAgilent34980ARoute2_get_SequenceTriggerSource(static_cast<Deriving*>(this), SequenceName, val);
	}
	STDMETHODIMP put_SequenceTriggerSource(BSTR SequenceName, Agilent34980ASequenceTriggerSourceEnum val)
	{
		return IAgilent34980ARoute2_put_SequenceTriggerSource(static_cast<Deriving*>(this), SequenceName, val);
	}
};

typedef __IAgilent34980ARoute2<Agilent34980A> _IAgilent34980ARoute2;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34980AStatus2
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34980AStatus2 : public IAgilent34980AStatus2
{
	STDMETHODIMP Preset()
	{
		return IAgilent34980AStatus_Preset(static_cast<Deriving*>(this));
	}
	STDMETHODIMP ConfigureServiceRequest(Agilent34980ASRQReasonEnum Reason)
	{
		return IAgilent34980AStatus_ConfigureServiceRequest(static_cast<Deriving*>(this), Reason);
	}
	STDMETHODIMP Clear()
	{
		return IAgilent34980AStatus_Clear(static_cast<Deriving*>(this));
	}
	STDMETHODIMP get_Register(Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long* val)
	{
		return IAgilent34980AStatus_get_Register(static_cast<Deriving*>(this), Register, SubRegister, val);
	}
	STDMETHODIMP put_Register(Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long val)
	{
		return IAgilent34980AStatus_put_Register(static_cast<Deriving*>(this), Register, SubRegister, val);
	}
	STDMETHODIMP get_SerialPoll(long* val)
	{
		return IAgilent34980AStatus_get_SerialPoll(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ModuleRegister(long Slot, Agilent34980AStatusSubRegisterEnum SubRegister, long* val)
	{
		return IAgilent34980AStatus2_get_ModuleRegister(static_cast<Deriving*>(this), Slot, SubRegister, val);
	}
	STDMETHODIMP put_ModuleRegister(long Slot, Agilent34980AStatusSubRegisterEnum SubRegister, long val)
	{
		return IAgilent34980AStatus2_put_ModuleRegister(static_cast<Deriving*>(this), Slot, SubRegister, val);
	}
};

typedef __IAgilent34980AStatus2<Agilent34980A> _IAgilent34980AStatus2;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviSwtchChannel
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviSwtchChannel : public IIviSwtchChannel
{
	STDMETHODIMP get_IsConfigurationChannel(VARIANT_BOOL* val)
	{
		return IIviSwtchChannel_get_IsConfigurationChannel(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_IsConfigurationChannel(VARIANT_BOOL val)
	{
		return IIviSwtchChannel_put_IsConfigurationChannel(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_IsSourceChannel(VARIANT_BOOL* val)
	{
		return IIviSwtchChannel_get_IsSourceChannel(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP put_IsSourceChannel(VARIANT_BOOL val)
	{
		return IIviSwtchChannel_put_IsSourceChannel(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Characteristics(IIviSwtchCharacteristics** val)
	{
		return IIviSwtchChannel_get_Characteristics(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviSwtchChannel<Agilent34980AChannel> _IIviSwtchChannel;


///////////////////////////////////////////////////////////////////////////////
//
//	IIviSwtchCharacteristics
//

template <typename Deriving> struct ATL_NO_VTABLE __IIviSwtchCharacteristics : public IIviSwtchCharacteristics
{
	STDMETHODIMP get_ACCurrentCarryMax(double* val)
	{
		return IIviSwtchCharacteristics_get_ACCurrentCarryMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ACCurrentSwitchingMax(double* val)
	{
		return IIviSwtchCharacteristics_get_ACCurrentSwitchingMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ACPowerCarryMax(double* val)
	{
		return IIviSwtchCharacteristics_get_ACPowerCarryMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ACPowerSwitchingMax(double* val)
	{
		return IIviSwtchCharacteristics_get_ACPowerSwitchingMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_ACVoltageMax(double* val)
	{
		return IIviSwtchCharacteristics_get_ACVoltageMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Bandwidth(double* val)
	{
		return IIviSwtchCharacteristics_get_Bandwidth(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DCCurrentCarryMax(double* val)
	{
		return IIviSwtchCharacteristics_get_DCCurrentCarryMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DCCurrentSwitchingMax(double* val)
	{
		return IIviSwtchCharacteristics_get_DCCurrentSwitchingMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DCPowerCarryMax(double* val)
	{
		return IIviSwtchCharacteristics_get_DCPowerCarryMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DCPowerSwitchingMax(double* val)
	{
		return IIviSwtchCharacteristics_get_DCPowerSwitchingMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_DCVoltageMax(double* val)
	{
		return IIviSwtchCharacteristics_get_DCVoltageMax(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Impedance(double* val)
	{
		return IIviSwtchCharacteristics_get_Impedance(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_SettlingTime(double* val)
	{
		return IIviSwtchCharacteristics_get_SettlingTime(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_WireMode(long* val)
	{
		return IIviSwtchCharacteristics_get_WireMode(static_cast<Deriving*>(this), val);
	}
};

typedef __IIviSwtchCharacteristics<Agilent34980AChannel> _IIviSwtchCharacteristics;




#endif // __FORWARDINGSHIMS_H__