/******************************************************************************
 *                                                                         
 *               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 Agilent34950A;


typedef CPersonality<Agilent34950A, CVisaComIOProvider> DriverBase;

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

	return &_comparePolicyManager;
}

HRESULT IAgilent34950AHandshake_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeModeEnum Mode, double Threshold, double Level);
HRESULT IAgilent34950AHandshake_GetPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineIDEnum Mode, Agilent34950APolarityEnum* val);
HRESULT IAgilent34950AHandshake_SetPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineIDEnum Mode, Agilent34950APolarityEnum Polarity);
HRESULT IAgilent34950AHandshake_get_AsyncTimeout(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AHandshake_put_AsyncTimeout(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950AHandshake_get_CycleTime(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AHandshake_put_CycleTime(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950AHandshake_get_Level(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AHandshake_put_Level(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950AHandshake_get_Mode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeModeEnum* val);
HRESULT IAgilent34950AHandshake_put_Mode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeModeEnum val);
HRESULT IAgilent34950AHandshake_get_Rate(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AHandshake_put_Rate(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950AHandshake_get_State(Agilent34950A* pT, BSTR ChannelList, Agilent34950AStateEnum* val);
HRESULT IAgilent34950AHandshake_put_State(Agilent34950A* pT, BSTR ChannelList, Agilent34950AStateEnum val);
HRESULT IAgilent34950AHandshake_get_SyncStrobe(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeStrobeSourceEnum* val);
HRESULT IAgilent34950AHandshake_put_SyncStrobe(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeStrobeSourceEnum val);
HRESULT IAgilent34950AHandshake_get_Threshold(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AHandshake_put_Threshold(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950AHandshake_get_Drive(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum* val);
HRESULT IAgilent34950AHandshake_put_Drive(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum val);
HRESULT IAgilent34950AInput_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AChannelWidthEnum Width, double Threshold);
HRESULT IAgilent34950AInput_get_Threshold(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AInput_put_Threshold(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950AInput_get_Memory(Agilent34950A* pT, IAgilent34950AInputMemory** val);
HRESULT IAgilent34950AInputMemory_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AActionEnum Action, long Count);
HRESULT IAgilent34950AInputMemory_Clear(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AInputMemory_InterruptSettings(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL State, Agilent34950AReportConditionEnum Mode, Agilent34950AHandshakeLineTypeEnum Drive);
HRESULT IAgilent34950AInputMemory_ReadAllData(Agilent34950A* pT, BSTR Channel, SAFEARRAY** val);
HRESULT IAgilent34950AInputMemory_ReadSelectedData(Agilent34950A* pT, BSTR Channel, long Index, long Count, SAFEARRAY** val);
HRESULT IAgilent34950AInputMemory_Start(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AInputMemory_Step(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AInputMemory_Stop(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AInputMemory_get_CompareAction(Agilent34950A* pT, BSTR ChannelList, Agilent34950AActionEnum* val);
HRESULT IAgilent34950AInputMemory_put_CompareAction(Agilent34950A* pT, BSTR ChannelList, Agilent34950AActionEnum val);
HRESULT IAgilent34950AInputMemory_get_DataFormat(Agilent34950A* pT, BSTR Channel, Agilent34950ADataFormatEnum* val);
HRESULT IAgilent34950AInputMemory_put_DataFormat(Agilent34950A* pT, BSTR Channel, Agilent34950ADataFormatEnum val);
HRESULT IAgilent34950AInputMemory_get_DataPoints(Agilent34950A* pT, BSTR Channel, long* val);
HRESULT IAgilent34950AInputMemory_get_Enable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34950AInputMemory_put_Enable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34950AInputMemory_get_InterruptMode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AReportConditionEnum* val);
HRESULT IAgilent34950AInputMemory_put_InterruptMode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AReportConditionEnum val);
HRESULT IAgilent34950AInputMemory_get_InterruptEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34950AInputMemory_put_InterruptEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34950AInputMemory_get_InterruptPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum* val);
HRESULT IAgilent34950AInputMemory_put_InterruptPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum val);
HRESULT IAgilent34950AInputMemory_get_InterruptStatus(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34950AInputMemory_get_SampleCount(Agilent34950A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34950AInputMemory_put_SampleCount(Agilent34950A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34950AInputMemory_get_Status(Agilent34950A* pT, BSTR Channel, VARIANT_BOOL* val);
HRESULT IAgilent34950AOutput_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AChannelWidthEnum Width, double VoltageLevel);
HRESULT IAgilent34950AOutput_get_Drive(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum* val);
HRESULT IAgilent34950AOutput_put_Drive(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum val);
HRESULT IAgilent34950AOutput_get_VoltLevel(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AOutput_put_VoltLevel(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950AOutput_get_Memory(Agilent34950A* pT, IAgilent34950AOutputMemory** val);
HRESULT IAgilent34950AOutputMemory_Configure(Agilent34950A* pT, BSTR Channel, BSTR TraceName, long Cycles);
HRESULT IAgilent34950AOutputMemory_Abort(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AOutputMemory_InterruptSettings(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL State, Agilent34950AOutputModeEnum Mode);
HRESULT IAgilent34950AOutputMemory_Start(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AOutputMemory_Step(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AOutputMemory_Stop(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AOutputMemory_get_CycleCount(Agilent34950A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34950AOutputMemory_put_CycleCount(Agilent34950A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34950AOutputMemory_get_Enable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34950AOutputMemory_put_Enable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34950AOutputMemory_get_InterruptEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34950AOutputMemory_put_InterruptEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34950AOutputMemory_get_InterruptMode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AOutputModeEnum* val);
HRESULT IAgilent34950AOutputMemory_put_InterruptMode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AOutputModeEnum val);
HRESULT IAgilent34950AOutputMemory_get_InterruptPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum* val);
HRESULT IAgilent34950AOutputMemory_put_InterruptPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum val);
HRESULT IAgilent34950AOutputMemory_get_TraceSelect(Agilent34950A* pT, BSTR Channel, BSTR* val);
HRESULT IAgilent34950AOutputMemory_put_TraceSelect(Agilent34950A* pT, BSTR Channel, BSTR val);
HRESULT IAgilent34950AOutputMemory_get_Status(Agilent34950A* pT, BSTR Channel, VARIANT_BOOL* val);
HRESULT IAgilent34950ATrace_CreateCustom(Agilent34950A* pT, BSTR Channel, BSTR Name, SAFEARRAY** Data, Agilent34950AChannelWidthEnum Width, long Points);
HRESULT IAgilent34950ATrace_CreateStandard(Agilent34950A* pT, BSTR Channel, Agilent34950ATraceTypeEnum Type, BSTR Name, long Points);
HRESULT IAgilent34950ATrace_Delete(Agilent34950A* pT, BSTR Channel, BSTR Name);
HRESULT IAgilent34950ATrace_DeleteAll(Agilent34950A* pT, BSTR Channel);
HRESULT IAgilent34950ATrace_GetPoints(Agilent34950A* pT, BSTR Channel, BSTR TraceName, long* val);
HRESULT IAgilent34950ATrace_get_Catalog(Agilent34950A* pT, BSTR Channel, BSTR* val);
HRESULT IAgilent34950ATrace_get_MemoryFree(Agilent34950A* pT, BSTR Channel, long* val);
HRESULT IAgilent34950ACounter_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AFunctionEnum Function, double GateTime);
HRESULT IAgilent34950ACounter_get_Function(Agilent34950A* pT, BSTR ChannelList, Agilent34950AFunctionEnum* val);
HRESULT IAgilent34950ACounter_put_Function(Agilent34950A* pT, BSTR ChannelList, Agilent34950AFunctionEnum val);
HRESULT IAgilent34950ACounter_get_GateTime(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950ACounter_put_GateTime(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950ACounter_get_GateSource(Agilent34950A* pT, BSTR ChannelList, Agilent34950AGateSourceEnum* val);
HRESULT IAgilent34950ACounter_put_GateSource(Agilent34950A* pT, BSTR ChannelList, Agilent34950AGateSourceEnum val);
HRESULT IAgilent34950ACounter_get_GatePolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum* val);
HRESULT IAgilent34950ACounter_put_GatePolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum val);
HRESULT IAgilent34950ACounter_get_GateThreshold(Agilent34950A* pT, long SlotNumber, double* val);
HRESULT IAgilent34950ACounter_put_GateThreshold(Agilent34950A* pT, long SlotNumber, double val);
HRESULT IAgilent34950ACounter_get_Slope(Agilent34950A* pT, BSTR ChannelList, Agilent34950ATotalizeSlopeEnum* val);
HRESULT IAgilent34950ACounter_put_Slope(Agilent34950A* pT, BSTR ChannelList, Agilent34950ATotalizeSlopeEnum val);
HRESULT IAgilent34950ACounter_get_Totalizer(Agilent34950A* pT, IAgilent34950ATotalizer** val);
HRESULT IAgilent34950ACounter_get_Measurement(Agilent34950A* pT, IAgilent34950AMeasurement** val);
HRESULT IAgilent34950ACounter_get_Threshold(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950ACounter_put_Threshold(Agilent34950A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34950ATotalizer_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AGateSourceEnum GateSource, Agilent34950ATotalizeTypeEnum ReadType);
HRESULT IAgilent34950ATotalizer_Clear(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950ATotalizer_ReadData(Agilent34950A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34950ATotalizer_get_ReadType(Agilent34950A* pT, BSTR ChannelList, Agilent34950ATotalizeTypeEnum* val);
HRESULT IAgilent34950ATotalizer_put_ReadType(Agilent34950A* pT, BSTR ChannelList, Agilent34950ATotalizeTypeEnum val);
HRESULT IAgilent34950AMeasurement_Abort(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AMeasurement_Initiate(Agilent34950A* pT, BSTR ChannelList);
HRESULT IAgilent34950AMeasurement_ReadData(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AMeasurement_get_Frequency(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AMeasurement_get_Period(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AMeasurement_get_PulseWidth(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AMeasurement_get_PulseDutyCycle(Agilent34950A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34950AMeasurement_get_TotalizeCount(Agilent34950A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34950AOutputClock_Configure(Agilent34950A* pT, double Frequency, long Slot, double Voltage);
HRESULT IAgilent34950AOutputClock_get_Frequency(Agilent34950A* pT, long Slot, double* val);
HRESULT IAgilent34950AOutputClock_put_Frequency(Agilent34950A* pT, long Slot, double val);
HRESULT IAgilent34950AOutputClock_get_State(Agilent34950A* pT, long Slot, VARIANT_BOOL* val);
HRESULT IAgilent34950AOutputClock_put_State(Agilent34950A* pT, long Slot, VARIANT_BOOL val);
HRESULT IAgilent34950AOutputClock_get_Level(Agilent34950A* pT, long Slot, double* val);
HRESULT IAgilent34950AOutputClock_put_Level(Agilent34950A* pT, long Slot, double val);
HRESULT IAgilent34950ADigital_QueryLastByte(Agilent34950A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34950ADigital_QueryLastWord(Agilent34950A* pT, BSTR ChannelList, short* val);
HRESULT IAgilent34950ADigital_ReadBit(Agilent34950A* pT, BSTR ChannelList, long BitNumber, VARIANT_BOOL* val);
HRESULT IAgilent34950ADigital_ReadByte(Agilent34950A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34950ADigital_ReadWord(Agilent34950A* pT, BSTR ChannelList, short* val);
HRESULT IAgilent34950ADigital_ReadLongWord(Agilent34950A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34950ADigital_WriteBit(Agilent34950A* pT, BSTR ChannelList, long Data, long BitNumber);
HRESULT IAgilent34950ADigital_WriteByte(Agilent34950A* pT, BSTR ChannelList, long Data);
HRESULT IAgilent34950ADigital_WriteWord(Agilent34950A* pT, BSTR ChannelList, long Data);
HRESULT IAgilent34950ADigital_WriteLongWord(Agilent34950A* pT, BSTR ChannelList, long Data);
HRESULT IAgilent34950ADigital_QueryLastBit(Agilent34950A* pT, BSTR ChannelList, long BitNumber, BYTE* val);
HRESULT IAgilent34950ADigital_QueryLastLongWord(Agilent34950A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34950ADigital_get_ComparisonEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34950ADigital_put_ComparisonEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34950ADigital_get_ComparisonType(Agilent34950A* pT, BSTR ChannelList, Agilent34950AComparisonTypeEnum* val);
HRESULT IAgilent34950ADigital_put_ComparisonType(Agilent34950A* pT, BSTR ChannelList, Agilent34950AComparisonTypeEnum val);
HRESULT IAgilent34950ADigital_get_Direction(Agilent34950A* pT, BSTR ChannelList, Agilent34950ADirectionEnum* val);
HRESULT IAgilent34950ADigital_put_Direction(Agilent34950A* pT, BSTR ChannelList, Agilent34950ADirectionEnum val);
HRESULT IAgilent34950ADigital_get_ComparisonDataByte(Agilent34950A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34950ADigital_put_ComparisonDataByte(Agilent34950A* pT, BSTR ChannelList, BYTE val);
HRESULT IAgilent34950ADigital_get_ComparisonDataWord(Agilent34950A* pT, BSTR ChannelList, short* val);
HRESULT IAgilent34950ADigital_put_ComparisonDataWord(Agilent34950A* pT, BSTR ChannelList, short val);
HRESULT IAgilent34950ADigital_get_ComparisonDataLongWord(Agilent34950A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34950ADigital_put_ComparisonDataLongWord(Agilent34950A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34950ADigital_get_ComparisonAlarmEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34950ADigital_put_ComparisonAlarmEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34950ADigital_get_ComparisonMaskByte(Agilent34950A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34950ADigital_put_ComparisonMaskByte(Agilent34950A* pT, BSTR ChannelList, BYTE val);
HRESULT IAgilent34950ADigital_get_ComparisonMaskWord(Agilent34950A* pT, BSTR ChannelList, short* val);
HRESULT IAgilent34950ADigital_put_ComparisonMaskWord(Agilent34950A* pT, BSTR ChannelList, short val);
HRESULT IAgilent34950ADigital_get_ComparisonMaskLongWord(Agilent34950A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34950ADigital_put_ComparisonMaskLongWord(Agilent34950A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34950ADigital_get_Width(Agilent34950A* pT, BSTR ChannelList, Agilent34950AChannelWidthEnum* val);
HRESULT IAgilent34950ADigital_put_Width(Agilent34950A* pT, BSTR ChannelList, Agilent34950AChannelWidthEnum val);
HRESULT IAgilent34950ADigital_get_Polarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum* val);
HRESULT IAgilent34950ADigital_put_Polarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum val);
HRESULT IAgilent34950ADigital_get_Handshake(Agilent34950A* pT, IAgilent34950AHandshake** val);
HRESULT IAgilent34950ADigital_get_Input(Agilent34950A* pT, IAgilent34950AInput** val);
HRESULT IAgilent34950ADigital_get_Output(Agilent34950A* pT, IAgilent34950AOutput** val);
HRESULT IAgilent34950ADigital_get_Trace(Agilent34950A* pT, IAgilent34950ATrace** val);
HRESULT IAgilent34950A_get_Digital(Agilent34950A* pT, IAgilent34950ADigital** val);
HRESULT IAgilent34950A_get_Counter(Agilent34950A* pT, IAgilent34950ACounter** val);
HRESULT IAgilent34950A_get_OutputClock(Agilent34950A* pT, IAgilent34950AOutputClock** val);


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950AHandshake
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950AHandshake : public IAgilent34950AHandshake
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34950AHandshakeModeEnum Mode, double Threshold, double Level)
	{
		return IAgilent34950AHandshake_Configure(static_cast<Deriving*>(this), ChannelList, Mode, Threshold, Level);
	}
	STDMETHODIMP GetPolarity(BSTR ChannelList, Agilent34950AHandshakeLineIDEnum Mode, Agilent34950APolarityEnum* val)
	{
		return IAgilent34950AHandshake_GetPolarity(static_cast<Deriving*>(this), ChannelList, Mode, val);
	}
	STDMETHODIMP SetPolarity(BSTR ChannelList, Agilent34950AHandshakeLineIDEnum Mode, Agilent34950APolarityEnum Polarity)
	{
		return IAgilent34950AHandshake_SetPolarity(static_cast<Deriving*>(this), ChannelList, Mode, Polarity);
	}
	STDMETHODIMP get_AsyncTimeout(BSTR ChannelList, double* val)
	{
		return IAgilent34950AHandshake_get_AsyncTimeout(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_AsyncTimeout(BSTR ChannelList, double val)
	{
		return IAgilent34950AHandshake_put_AsyncTimeout(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_CycleTime(BSTR ChannelList, double* val)
	{
		return IAgilent34950AHandshake_get_CycleTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_CycleTime(BSTR ChannelList, double val)
	{
		return IAgilent34950AHandshake_put_CycleTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Level(BSTR ChannelList, double* val)
	{
		return IAgilent34950AHandshake_get_Level(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Level(BSTR ChannelList, double val)
	{
		return IAgilent34950AHandshake_put_Level(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Mode(BSTR ChannelList, Agilent34950AHandshakeModeEnum* val)
	{
		return IAgilent34950AHandshake_get_Mode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Mode(BSTR ChannelList, Agilent34950AHandshakeModeEnum val)
	{
		return IAgilent34950AHandshake_put_Mode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Rate(BSTR ChannelList, double* val)
	{
		return IAgilent34950AHandshake_get_Rate(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Rate(BSTR ChannelList, double val)
	{
		return IAgilent34950AHandshake_put_Rate(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_State(BSTR ChannelList, Agilent34950AStateEnum* val)
	{
		return IAgilent34950AHandshake_get_State(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_State(BSTR ChannelList, Agilent34950AStateEnum val)
	{
		return IAgilent34950AHandshake_put_State(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_SyncStrobe(BSTR ChannelList, Agilent34950AHandshakeStrobeSourceEnum* val)
	{
		return IAgilent34950AHandshake_get_SyncStrobe(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_SyncStrobe(BSTR ChannelList, Agilent34950AHandshakeStrobeSourceEnum val)
	{
		return IAgilent34950AHandshake_put_SyncStrobe(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Threshold(BSTR ChannelList, double* val)
	{
		return IAgilent34950AHandshake_get_Threshold(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Threshold(BSTR ChannelList, double val)
	{
		return IAgilent34950AHandshake_put_Threshold(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Drive(BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum* val)
	{
		return IAgilent34950AHandshake_get_Drive(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Drive(BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum val)
	{
		return IAgilent34950AHandshake_put_Drive(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34950AHandshake<Agilent34950A> _IAgilent34950AHandshake;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950AInput
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950AInput : public IAgilent34950AInput
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34950AChannelWidthEnum Width, double Threshold)
	{
		return IAgilent34950AInput_Configure(static_cast<Deriving*>(this), ChannelList, Width, Threshold);
	}
	STDMETHODIMP get_Threshold(BSTR ChannelList, double* val)
	{
		return IAgilent34950AInput_get_Threshold(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Threshold(BSTR ChannelList, double val)
	{
		return IAgilent34950AInput_put_Threshold(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Memory(IAgilent34950AInputMemory** val)
	{
		return IAgilent34950AInput_get_Memory(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34950AInput<Agilent34950A> _IAgilent34950AInput;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950AInputMemory
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950AInputMemory : public IAgilent34950AInputMemory
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34950AActionEnum Action, long Count)
	{
		return IAgilent34950AInputMemory_Configure(static_cast<Deriving*>(this), ChannelList, Action, Count);
	}
	STDMETHODIMP Clear(BSTR ChannelList)
	{
		return IAgilent34950AInputMemory_Clear(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP InterruptSettings(BSTR ChannelList, VARIANT_BOOL State, Agilent34950AReportConditionEnum Mode, Agilent34950AHandshakeLineTypeEnum Drive)
	{
		return IAgilent34950AInputMemory_InterruptSettings(static_cast<Deriving*>(this), ChannelList, State, Mode, Drive);
	}
	STDMETHODIMP ReadAllData(BSTR Channel, SAFEARRAY** val)
	{
		return IAgilent34950AInputMemory_ReadAllData(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP ReadSelectedData(BSTR Channel, long Index, long Count, SAFEARRAY** val)
	{
		return IAgilent34950AInputMemory_ReadSelectedData(static_cast<Deriving*>(this), Channel, Index, Count, val);
	}
	STDMETHODIMP Start(BSTR ChannelList)
	{
		return IAgilent34950AInputMemory_Start(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Step(BSTR ChannelList)
	{
		return IAgilent34950AInputMemory_Step(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Stop(BSTR ChannelList)
	{
		return IAgilent34950AInputMemory_Stop(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP get_CompareAction(BSTR ChannelList, Agilent34950AActionEnum* val)
	{
		return IAgilent34950AInputMemory_get_CompareAction(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_CompareAction(BSTR ChannelList, Agilent34950AActionEnum val)
	{
		return IAgilent34950AInputMemory_put_CompareAction(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_DataFormat(BSTR Channel, Agilent34950ADataFormatEnum* val)
	{
		return IAgilent34950AInputMemory_get_DataFormat(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP put_DataFormat(BSTR Channel, Agilent34950ADataFormatEnum val)
	{
		return IAgilent34950AInputMemory_put_DataFormat(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP get_DataPoints(BSTR Channel, long* val)
	{
		return IAgilent34950AInputMemory_get_DataPoints(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP get_Enable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34950AInputMemory_get_Enable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Enable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34950AInputMemory_put_Enable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_InterruptMode(BSTR ChannelList, Agilent34950AReportConditionEnum* val)
	{
		return IAgilent34950AInputMemory_get_InterruptMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_InterruptMode(BSTR ChannelList, Agilent34950AReportConditionEnum val)
	{
		return IAgilent34950AInputMemory_put_InterruptMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_InterruptEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34950AInputMemory_get_InterruptEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_InterruptEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34950AInputMemory_put_InterruptEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_InterruptPolarity(BSTR ChannelList, Agilent34950APolarityEnum* val)
	{
		return IAgilent34950AInputMemory_get_InterruptPolarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_InterruptPolarity(BSTR ChannelList, Agilent34950APolarityEnum val)
	{
		return IAgilent34950AInputMemory_put_InterruptPolarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_InterruptStatus(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34950AInputMemory_get_InterruptStatus(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_SampleCount(BSTR ChannelList, long* val)
	{
		return IAgilent34950AInputMemory_get_SampleCount(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_SampleCount(BSTR ChannelList, long val)
	{
		return IAgilent34950AInputMemory_put_SampleCount(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Status(BSTR Channel, VARIANT_BOOL* val)
	{
		return IAgilent34950AInputMemory_get_Status(static_cast<Deriving*>(this), Channel, val);
	}
};

typedef __IAgilent34950AInputMemory<Agilent34950A> _IAgilent34950AInputMemory;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950AOutput
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950AOutput : public IAgilent34950AOutput
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34950AChannelWidthEnum Width, double VoltageLevel)
	{
		return IAgilent34950AOutput_Configure(static_cast<Deriving*>(this), ChannelList, Width, VoltageLevel);
	}
	STDMETHODIMP get_Drive(BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum* val)
	{
		return IAgilent34950AOutput_get_Drive(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Drive(BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum val)
	{
		return IAgilent34950AOutput_put_Drive(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_VoltLevel(BSTR ChannelList, double* val)
	{
		return IAgilent34950AOutput_get_VoltLevel(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_VoltLevel(BSTR ChannelList, double val)
	{
		return IAgilent34950AOutput_put_VoltLevel(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Memory(IAgilent34950AOutputMemory** val)
	{
		return IAgilent34950AOutput_get_Memory(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34950AOutput<Agilent34950A> _IAgilent34950AOutput;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950AOutputMemory
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950AOutputMemory : public IAgilent34950AOutputMemory
{
	STDMETHODIMP Configure(BSTR Channel, BSTR TraceName, long Cycles)
	{
		return IAgilent34950AOutputMemory_Configure(static_cast<Deriving*>(this), Channel, TraceName, Cycles);
	}
	STDMETHODIMP Abort(BSTR ChannelList)
	{
		return IAgilent34950AOutputMemory_Abort(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP InterruptSettings(BSTR ChannelList, VARIANT_BOOL State, Agilent34950AOutputModeEnum Mode)
	{
		return IAgilent34950AOutputMemory_InterruptSettings(static_cast<Deriving*>(this), ChannelList, State, Mode);
	}
	STDMETHODIMP Start(BSTR ChannelList)
	{
		return IAgilent34950AOutputMemory_Start(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Step(BSTR ChannelList)
	{
		return IAgilent34950AOutputMemory_Step(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Stop(BSTR ChannelList)
	{
		return IAgilent34950AOutputMemory_Stop(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP get_CycleCount(BSTR ChannelList, long* val)
	{
		return IAgilent34950AOutputMemory_get_CycleCount(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_CycleCount(BSTR ChannelList, long val)
	{
		return IAgilent34950AOutputMemory_put_CycleCount(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Enable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34950AOutputMemory_get_Enable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Enable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34950AOutputMemory_put_Enable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_InterruptEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34950AOutputMemory_get_InterruptEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_InterruptEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34950AOutputMemory_put_InterruptEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_InterruptMode(BSTR ChannelList, Agilent34950AOutputModeEnum* val)
	{
		return IAgilent34950AOutputMemory_get_InterruptMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_InterruptMode(BSTR ChannelList, Agilent34950AOutputModeEnum val)
	{
		return IAgilent34950AOutputMemory_put_InterruptMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_InterruptPolarity(BSTR ChannelList, Agilent34950APolarityEnum* val)
	{
		return IAgilent34950AOutputMemory_get_InterruptPolarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_InterruptPolarity(BSTR ChannelList, Agilent34950APolarityEnum val)
	{
		return IAgilent34950AOutputMemory_put_InterruptPolarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_TraceSelect(BSTR Channel, BSTR* val)
	{
		return IAgilent34950AOutputMemory_get_TraceSelect(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP put_TraceSelect(BSTR Channel, BSTR val)
	{
		return IAgilent34950AOutputMemory_put_TraceSelect(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP get_Status(BSTR Channel, VARIANT_BOOL* val)
	{
		return IAgilent34950AOutputMemory_get_Status(static_cast<Deriving*>(this), Channel, val);
	}
};

typedef __IAgilent34950AOutputMemory<Agilent34950A> _IAgilent34950AOutputMemory;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950ATrace
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950ATrace : public IAgilent34950ATrace
{
	STDMETHODIMP CreateCustom(BSTR Channel, BSTR Name, SAFEARRAY** Data, Agilent34950AChannelWidthEnum Width, long Points)
	{
		return IAgilent34950ATrace_CreateCustom(static_cast<Deriving*>(this), Channel, Name, Data, Width, Points);
	}
	STDMETHODIMP CreateStandard(BSTR Channel, Agilent34950ATraceTypeEnum Type, BSTR Name, long Points)
	{
		return IAgilent34950ATrace_CreateStandard(static_cast<Deriving*>(this), Channel, Type, Name, Points);
	}
	STDMETHODIMP Delete(BSTR Channel, BSTR Name)
	{
		return IAgilent34950ATrace_Delete(static_cast<Deriving*>(this), Channel, Name);
	}
	STDMETHODIMP DeleteAll(BSTR Channel)
	{
		return IAgilent34950ATrace_DeleteAll(static_cast<Deriving*>(this), Channel);
	}
	STDMETHODIMP GetPoints(BSTR Channel, BSTR TraceName, long* val)
	{
		return IAgilent34950ATrace_GetPoints(static_cast<Deriving*>(this), Channel, TraceName, val);
	}
	STDMETHODIMP get_Catalog(BSTR Channel, BSTR* val)
	{
		return IAgilent34950ATrace_get_Catalog(static_cast<Deriving*>(this), Channel, val);
	}
	STDMETHODIMP get_MemoryFree(BSTR Channel, long* val)
	{
		return IAgilent34950ATrace_get_MemoryFree(static_cast<Deriving*>(this), Channel, val);
	}
};

typedef __IAgilent34950ATrace<Agilent34950A> _IAgilent34950ATrace;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950ACounter
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950ACounter : public IAgilent34950ACounter
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34950AFunctionEnum Function, double GateTime)
	{
		return IAgilent34950ACounter_Configure(static_cast<Deriving*>(this), ChannelList, Function, GateTime);
	}
	STDMETHODIMP get_Function(BSTR ChannelList, Agilent34950AFunctionEnum* val)
	{
		return IAgilent34950ACounter_get_Function(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Function(BSTR ChannelList, Agilent34950AFunctionEnum val)
	{
		return IAgilent34950ACounter_put_Function(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_GateTime(BSTR ChannelList, double* val)
	{
		return IAgilent34950ACounter_get_GateTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_GateTime(BSTR ChannelList, double val)
	{
		return IAgilent34950ACounter_put_GateTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_GateSource(BSTR ChannelList, Agilent34950AGateSourceEnum* val)
	{
		return IAgilent34950ACounter_get_GateSource(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_GateSource(BSTR ChannelList, Agilent34950AGateSourceEnum val)
	{
		return IAgilent34950ACounter_put_GateSource(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_GatePolarity(BSTR ChannelList, Agilent34950APolarityEnum* val)
	{
		return IAgilent34950ACounter_get_GatePolarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_GatePolarity(BSTR ChannelList, Agilent34950APolarityEnum val)
	{
		return IAgilent34950ACounter_put_GatePolarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_GateThreshold(long SlotNumber, double* val)
	{
		return IAgilent34950ACounter_get_GateThreshold(static_cast<Deriving*>(this), SlotNumber, val);
	}
	STDMETHODIMP put_GateThreshold(long SlotNumber, double val)
	{
		return IAgilent34950ACounter_put_GateThreshold(static_cast<Deriving*>(this), SlotNumber, val);
	}
	STDMETHODIMP get_Slope(BSTR ChannelList, Agilent34950ATotalizeSlopeEnum* val)
	{
		return IAgilent34950ACounter_get_Slope(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Slope(BSTR ChannelList, Agilent34950ATotalizeSlopeEnum val)
	{
		return IAgilent34950ACounter_put_Slope(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Totalizer(IAgilent34950ATotalizer** val)
	{
		return IAgilent34950ACounter_get_Totalizer(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Measurement(IAgilent34950AMeasurement** val)
	{
		return IAgilent34950ACounter_get_Measurement(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Threshold(BSTR ChannelList, double* val)
	{
		return IAgilent34950ACounter_get_Threshold(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Threshold(BSTR ChannelList, double val)
	{
		return IAgilent34950ACounter_put_Threshold(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34950ACounter<Agilent34950A> _IAgilent34950ACounter;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950ATotalizer
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950ATotalizer : public IAgilent34950ATotalizer
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34950AGateSourceEnum GateSource, Agilent34950ATotalizeTypeEnum ReadType)
	{
		return IAgilent34950ATotalizer_Configure(static_cast<Deriving*>(this), ChannelList, GateSource, ReadType);
	}
	STDMETHODIMP Clear(BSTR ChannelList)
	{
		return IAgilent34950ATotalizer_Clear(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP ReadData(BSTR ChannelList, long* val)
	{
		return IAgilent34950ATotalizer_ReadData(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ReadType(BSTR ChannelList, Agilent34950ATotalizeTypeEnum* val)
	{
		return IAgilent34950ATotalizer_get_ReadType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ReadType(BSTR ChannelList, Agilent34950ATotalizeTypeEnum val)
	{
		return IAgilent34950ATotalizer_put_ReadType(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34950ATotalizer<Agilent34950A> _IAgilent34950ATotalizer;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950AMeasurement
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950AMeasurement : public IAgilent34950AMeasurement
{
	STDMETHODIMP Abort(BSTR ChannelList)
	{
		return IAgilent34950AMeasurement_Abort(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Initiate(BSTR ChannelList)
	{
		return IAgilent34950AMeasurement_Initiate(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP ReadData(BSTR ChannelList, double* val)
	{
		return IAgilent34950AMeasurement_ReadData(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Frequency(BSTR ChannelList, double* val)
	{
		return IAgilent34950AMeasurement_get_Frequency(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Period(BSTR ChannelList, double* val)
	{
		return IAgilent34950AMeasurement_get_Period(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_PulseWidth(BSTR ChannelList, double* val)
	{
		return IAgilent34950AMeasurement_get_PulseWidth(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_PulseDutyCycle(BSTR ChannelList, double* val)
	{
		return IAgilent34950AMeasurement_get_PulseDutyCycle(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_TotalizeCount(BSTR ChannelList, long* val)
	{
		return IAgilent34950AMeasurement_get_TotalizeCount(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34950AMeasurement<Agilent34950A> _IAgilent34950AMeasurement;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950AOutputClock
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950AOutputClock : public IAgilent34950AOutputClock
{
	STDMETHODIMP Configure(double Frequency, long Slot, double Voltage)
	{
		return IAgilent34950AOutputClock_Configure(static_cast<Deriving*>(this), Frequency, Slot, Voltage);
	}
	STDMETHODIMP get_Frequency(long Slot, double* val)
	{
		return IAgilent34950AOutputClock_get_Frequency(static_cast<Deriving*>(this), Slot, val);
	}
	STDMETHODIMP put_Frequency(long Slot, double val)
	{
		return IAgilent34950AOutputClock_put_Frequency(static_cast<Deriving*>(this), Slot, val);
	}
	STDMETHODIMP get_State(long Slot, VARIANT_BOOL* val)
	{
		return IAgilent34950AOutputClock_get_State(static_cast<Deriving*>(this), Slot, val);
	}
	STDMETHODIMP put_State(long Slot, VARIANT_BOOL val)
	{
		return IAgilent34950AOutputClock_put_State(static_cast<Deriving*>(this), Slot, val);
	}
	STDMETHODIMP get_Level(long Slot, double* val)
	{
		return IAgilent34950AOutputClock_get_Level(static_cast<Deriving*>(this), Slot, val);
	}
	STDMETHODIMP put_Level(long Slot, double val)
	{
		return IAgilent34950AOutputClock_put_Level(static_cast<Deriving*>(this), Slot, val);
	}
};

typedef __IAgilent34950AOutputClock<Agilent34950A> _IAgilent34950AOutputClock;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950ADigital
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950ADigital : public IAgilent34950ADigital
{
	STDMETHODIMP QueryLastByte(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34950ADigital_QueryLastByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP QueryLastWord(BSTR ChannelList, short* val)
	{
		return IAgilent34950ADigital_QueryLastWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP ReadBit(BSTR ChannelList, long BitNumber, VARIANT_BOOL* val)
	{
		return IAgilent34950ADigital_ReadBit(static_cast<Deriving*>(this), ChannelList, BitNumber, val);
	}
	STDMETHODIMP ReadByte(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34950ADigital_ReadByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP ReadWord(BSTR ChannelList, short* val)
	{
		return IAgilent34950ADigital_ReadWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP ReadLongWord(BSTR ChannelList, long* val)
	{
		return IAgilent34950ADigital_ReadLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP WriteBit(BSTR ChannelList, long Data, long BitNumber)
	{
		return IAgilent34950ADigital_WriteBit(static_cast<Deriving*>(this), ChannelList, Data, BitNumber);
	}
	STDMETHODIMP WriteByte(BSTR ChannelList, long Data)
	{
		return IAgilent34950ADigital_WriteByte(static_cast<Deriving*>(this), ChannelList, Data);
	}
	STDMETHODIMP WriteWord(BSTR ChannelList, long Data)
	{
		return IAgilent34950ADigital_WriteWord(static_cast<Deriving*>(this), ChannelList, Data);
	}
	STDMETHODIMP WriteLongWord(BSTR ChannelList, long Data)
	{
		return IAgilent34950ADigital_WriteLongWord(static_cast<Deriving*>(this), ChannelList, Data);
	}
	STDMETHODIMP QueryLastBit(BSTR ChannelList, long BitNumber, BYTE* val)
	{
		return IAgilent34950ADigital_QueryLastBit(static_cast<Deriving*>(this), ChannelList, BitNumber, val);
	}
	STDMETHODIMP QueryLastLongWord(BSTR ChannelList, long* val)
	{
		return IAgilent34950ADigital_QueryLastLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34950ADigital_get_ComparisonEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34950ADigital_put_ComparisonEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonType(BSTR ChannelList, Agilent34950AComparisonTypeEnum* val)
	{
		return IAgilent34950ADigital_get_ComparisonType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonType(BSTR ChannelList, Agilent34950AComparisonTypeEnum val)
	{
		return IAgilent34950ADigital_put_ComparisonType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Direction(BSTR ChannelList, Agilent34950ADirectionEnum* val)
	{
		return IAgilent34950ADigital_get_Direction(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Direction(BSTR ChannelList, Agilent34950ADirectionEnum val)
	{
		return IAgilent34950ADigital_put_Direction(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonDataByte(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34950ADigital_get_ComparisonDataByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonDataByte(BSTR ChannelList, BYTE val)
	{
		return IAgilent34950ADigital_put_ComparisonDataByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonDataWord(BSTR ChannelList, short* val)
	{
		return IAgilent34950ADigital_get_ComparisonDataWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonDataWord(BSTR ChannelList, short val)
	{
		return IAgilent34950ADigital_put_ComparisonDataWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonDataLongWord(BSTR ChannelList, long* val)
	{
		return IAgilent34950ADigital_get_ComparisonDataLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonDataLongWord(BSTR ChannelList, long val)
	{
		return IAgilent34950ADigital_put_ComparisonDataLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonAlarmEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34950ADigital_get_ComparisonAlarmEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonAlarmEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34950ADigital_put_ComparisonAlarmEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonMaskByte(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34950ADigital_get_ComparisonMaskByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonMaskByte(BSTR ChannelList, BYTE val)
	{
		return IAgilent34950ADigital_put_ComparisonMaskByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonMaskWord(BSTR ChannelList, short* val)
	{
		return IAgilent34950ADigital_get_ComparisonMaskWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonMaskWord(BSTR ChannelList, short val)
	{
		return IAgilent34950ADigital_put_ComparisonMaskWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonMaskLongWord(BSTR ChannelList, long* val)
	{
		return IAgilent34950ADigital_get_ComparisonMaskLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonMaskLongWord(BSTR ChannelList, long val)
	{
		return IAgilent34950ADigital_put_ComparisonMaskLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Width(BSTR ChannelList, Agilent34950AChannelWidthEnum* val)
	{
		return IAgilent34950ADigital_get_Width(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Width(BSTR ChannelList, Agilent34950AChannelWidthEnum val)
	{
		return IAgilent34950ADigital_put_Width(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Polarity(BSTR ChannelList, Agilent34950APolarityEnum* val)
	{
		return IAgilent34950ADigital_get_Polarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Polarity(BSTR ChannelList, Agilent34950APolarityEnum val)
	{
		return IAgilent34950ADigital_put_Polarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Handshake(IAgilent34950AHandshake** val)
	{
		return IAgilent34950ADigital_get_Handshake(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Input(IAgilent34950AInput** val)
	{
		return IAgilent34950ADigital_get_Input(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Output(IAgilent34950AOutput** val)
	{
		return IAgilent34950ADigital_get_Output(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Trace(IAgilent34950ATrace** val)
	{
		return IAgilent34950ADigital_get_Trace(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34950ADigital<Agilent34950A> _IAgilent34950ADigital;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34950A
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34950A : public IAgilent34950A
{
	STDMETHODIMP get_Digital(IAgilent34950ADigital** val)
	{
		return IAgilent34950A_get_Digital(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Counter(IAgilent34950ACounter** val)
	{
		return IAgilent34950A_get_Counter(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_OutputClock(IAgilent34950AOutputClock** val)
	{
		return IAgilent34950A_get_OutputClock(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34950A<Agilent34950A> _IAgilent34950A;




#endif // __FORWARDINGSHIMS_H__