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


typedef CPersonality<Agilent34952A, CVisaComIOProvider> DriverBase;

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

	return &_comparePolicyManager;
}

HRESULT IAgilent34952A_get_DAC(Agilent34952A* pT, IAgilent34952ADAC** val);
HRESULT IAgilent34952A_get_Digital(Agilent34952A* pT, IAgilent34952ADigital** val);
HRESULT IAgilent34952A_get_Totalize(Agilent34952A* pT, IAgilent34952ATotalize** val);
HRESULT IAgilent34952ADAC_get_Voltage(Agilent34952A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34952ADAC_put_Voltage(Agilent34952A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34952ADigital_Configure(Agilent34952A* pT, BSTR ChannelList, Agilent34952ADigitalModeEnum Mode, Agilent34952ADirectionEnum Direction);
HRESULT IAgilent34952ADigital_QueryLastByte(Agilent34952A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34952ADigital_QueryLastWord(Agilent34952A* pT, BSTR ChannelList, short* val);
HRESULT IAgilent34952ADigital_ReadBit(Agilent34952A* pT, BSTR ChannelList, long BitNumber, VARIANT_BOOL* val);
HRESULT IAgilent34952ADigital_ReadByte(Agilent34952A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34952ADigital_ReadWord(Agilent34952A* pT, BSTR ChannelList, short* val);
HRESULT IAgilent34952ADigital_ReadLongWord(Agilent34952A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34952ADigital_WriteBit(Agilent34952A* pT, BSTR ChannelList, long BitNumber, long Data);
HRESULT IAgilent34952ADigital_WriteByte(Agilent34952A* pT, BSTR ChannelList, BYTE Data);
HRESULT IAgilent34952ADigital_WriteWord(Agilent34952A* pT, BSTR ChannelList, short Data);
HRESULT IAgilent34952ADigital_WriteLongWord(Agilent34952A* pT, BSTR ChannelList, long Data);
HRESULT IAgilent34952ADigital_get_ComparisonData(Agilent34952A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34952ADigital_put_ComparisonData(Agilent34952A* pT, BSTR ChannelList, BYTE val);
HRESULT IAgilent34952ADigital_get_ComparisonEnable(Agilent34952A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34952ADigital_put_ComparisonEnable(Agilent34952A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34952ADigital_get_ComparisonMask(Agilent34952A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34952ADigital_put_ComparisonMask(Agilent34952A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34952ADigital_get_ComparisonType(Agilent34952A* pT, BSTR ChannelList, Agilent34952AComparisonTypeEnum* val);
HRESULT IAgilent34952ADigital_put_ComparisonType(Agilent34952A* pT, BSTR ChannelList, Agilent34952AComparisonTypeEnum val);
HRESULT IAgilent34952ADigital_get_State(Agilent34952A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34952ADigital_get_Direction(Agilent34952A* pT, BSTR ChannelList, Agilent34952ADirectionEnum* val);
HRESULT IAgilent34952ADigital_put_Direction(Agilent34952A* pT, BSTR ChannelList, Agilent34952ADirectionEnum val);
HRESULT IAgilent34952ADigital_get_ComparisonDataByte(Agilent34952A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34952ADigital_put_ComparisonDataByte(Agilent34952A* pT, BSTR ChannelList, BYTE val);
HRESULT IAgilent34952ADigital_get_ComparisonDataWord(Agilent34952A* pT, BSTR ChannelList, short* val);
HRESULT IAgilent34952ADigital_put_ComparisonDataWord(Agilent34952A* pT, BSTR ChannelList, short val);
HRESULT IAgilent34952ADigital_get_ComparisonDataLongWord(Agilent34952A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34952ADigital_put_ComparisonDataLongWord(Agilent34952A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34952ADigital_get_ComparisonMaskByte(Agilent34952A* pT, BSTR ChannelList, BYTE* val);
HRESULT IAgilent34952ADigital_put_ComparisonMaskByte(Agilent34952A* pT, BSTR ChannelList, BYTE val);
HRESULT IAgilent34952ADigital_get_ComparisonMaskWord(Agilent34952A* pT, BSTR ChannelList, short* val);
HRESULT IAgilent34952ADigital_put_ComparisonMaskWord(Agilent34952A* pT, BSTR ChannelList, short val);
HRESULT IAgilent34952ADigital_get_ComparisonMaskLongWord(Agilent34952A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34952ADigital_put_ComparisonMaskLongWord(Agilent34952A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34952ATotalize_ClearTotal(Agilent34952A* pT, BSTR ChannelList);
HRESULT IAgilent34952ATotalize_Configure(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeTypeEnum Type, Agilent34952ATotalizeThresholdModeEnum Mode, Agilent34952ATotalizeSlopeEnum Slope);
HRESULT IAgilent34952ATotalize_ReadData(Agilent34952A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34952ATotalize_get_Mode(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeThresholdModeEnum* val);
HRESULT IAgilent34952ATotalize_put_Mode(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeThresholdModeEnum val);
HRESULT IAgilent34952ATotalize_get_ReadType(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeTypeEnum* val);
HRESULT IAgilent34952ATotalize_put_ReadType(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeTypeEnum val);
HRESULT IAgilent34952ATotalize_get_Slope(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeSlopeEnum* val);
HRESULT IAgilent34952ATotalize_put_Slope(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeSlopeEnum val);


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34952A
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34952A : public IAgilent34952A
{
	STDMETHODIMP get_DAC(IAgilent34952ADAC** val)
	{
		return IAgilent34952A_get_DAC(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Digital(IAgilent34952ADigital** val)
	{
		return IAgilent34952A_get_Digital(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Totalize(IAgilent34952ATotalize** val)
	{
		return IAgilent34952A_get_Totalize(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34952A<Agilent34952A> _IAgilent34952A;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34952ADAC
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34952ADAC : public IAgilent34952ADAC
{
	STDMETHODIMP get_Voltage(BSTR ChannelList, double* val)
	{
		return IAgilent34952ADAC_get_Voltage(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Voltage(BSTR ChannelList, double val)
	{
		return IAgilent34952ADAC_put_Voltage(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34952ADAC<Agilent34952A> _IAgilent34952ADAC;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34952ADigital
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34952ADigital : public IAgilent34952ADigital
{
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34952ADigitalModeEnum Mode, Agilent34952ADirectionEnum Direction)
	{
		return IAgilent34952ADigital_Configure(static_cast<Deriving*>(this), ChannelList, Mode, Direction);
	}
	STDMETHODIMP QueryLastByte(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34952ADigital_QueryLastByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP QueryLastWord(BSTR ChannelList, short* val)
	{
		return IAgilent34952ADigital_QueryLastWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP ReadBit(BSTR ChannelList, long BitNumber, VARIANT_BOOL* val)
	{
		return IAgilent34952ADigital_ReadBit(static_cast<Deriving*>(this), ChannelList, BitNumber, val);
	}
	STDMETHODIMP ReadByte(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34952ADigital_ReadByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP ReadWord(BSTR ChannelList, short* val)
	{
		return IAgilent34952ADigital_ReadWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP ReadLongWord(BSTR ChannelList, long* val)
	{
		return IAgilent34952ADigital_ReadLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP WriteBit(BSTR ChannelList, long BitNumber, long Data)
	{
		return IAgilent34952ADigital_WriteBit(static_cast<Deriving*>(this), ChannelList, BitNumber, Data);
	}
	STDMETHODIMP WriteByte(BSTR ChannelList, BYTE Data)
	{
		return IAgilent34952ADigital_WriteByte(static_cast<Deriving*>(this), ChannelList, Data);
	}
	STDMETHODIMP WriteWord(BSTR ChannelList, short Data)
	{
		return IAgilent34952ADigital_WriteWord(static_cast<Deriving*>(this), ChannelList, Data);
	}
	STDMETHODIMP WriteLongWord(BSTR ChannelList, long Data)
	{
		return IAgilent34952ADigital_WriteLongWord(static_cast<Deriving*>(this), ChannelList, Data);
	}
	STDMETHODIMP get_ComparisonData(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34952ADigital_get_ComparisonData(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonData(BSTR ChannelList, BYTE val)
	{
		return IAgilent34952ADigital_put_ComparisonData(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34952ADigital_get_ComparisonEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34952ADigital_put_ComparisonEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonMask(BSTR ChannelList, long* val)
	{
		return IAgilent34952ADigital_get_ComparisonMask(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonMask(BSTR ChannelList, long val)
	{
		return IAgilent34952ADigital_put_ComparisonMask(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonType(BSTR ChannelList, Agilent34952AComparisonTypeEnum* val)
	{
		return IAgilent34952ADigital_get_ComparisonType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonType(BSTR ChannelList, Agilent34952AComparisonTypeEnum val)
	{
		return IAgilent34952ADigital_put_ComparisonType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_State(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34952ADigital_get_State(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Direction(BSTR ChannelList, Agilent34952ADirectionEnum* val)
	{
		return IAgilent34952ADigital_get_Direction(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Direction(BSTR ChannelList, Agilent34952ADirectionEnum val)
	{
		return IAgilent34952ADigital_put_Direction(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonDataByte(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34952ADigital_get_ComparisonDataByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonDataByte(BSTR ChannelList, BYTE val)
	{
		return IAgilent34952ADigital_put_ComparisonDataByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonDataWord(BSTR ChannelList, short* val)
	{
		return IAgilent34952ADigital_get_ComparisonDataWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonDataWord(BSTR ChannelList, short val)
	{
		return IAgilent34952ADigital_put_ComparisonDataWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonDataLongWord(BSTR ChannelList, long* val)
	{
		return IAgilent34952ADigital_get_ComparisonDataLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonDataLongWord(BSTR ChannelList, long val)
	{
		return IAgilent34952ADigital_put_ComparisonDataLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonMaskByte(BSTR ChannelList, BYTE* val)
	{
		return IAgilent34952ADigital_get_ComparisonMaskByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonMaskByte(BSTR ChannelList, BYTE val)
	{
		return IAgilent34952ADigital_put_ComparisonMaskByte(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonMaskWord(BSTR ChannelList, short* val)
	{
		return IAgilent34952ADigital_get_ComparisonMaskWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonMaskWord(BSTR ChannelList, short val)
	{
		return IAgilent34952ADigital_put_ComparisonMaskWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ComparisonMaskLongWord(BSTR ChannelList, long* val)
	{
		return IAgilent34952ADigital_get_ComparisonMaskLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ComparisonMaskLongWord(BSTR ChannelList, long val)
	{
		return IAgilent34952ADigital_put_ComparisonMaskLongWord(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34952ADigital<Agilent34952A> _IAgilent34952ADigital;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34952ATotalize
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34952ATotalize : public IAgilent34952ATotalize
{
	STDMETHODIMP ClearTotal(BSTR ChannelList)
	{
		return IAgilent34952ATotalize_ClearTotal(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Configure(BSTR ChannelList, Agilent34952ATotalizeTypeEnum Type, Agilent34952ATotalizeThresholdModeEnum Mode, Agilent34952ATotalizeSlopeEnum Slope)
	{
		return IAgilent34952ATotalize_Configure(static_cast<Deriving*>(this), ChannelList, Type, Mode, Slope);
	}
	STDMETHODIMP ReadData(BSTR ChannelList, double* val)
	{
		return IAgilent34952ATotalize_ReadData(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Mode(BSTR ChannelList, Agilent34952ATotalizeThresholdModeEnum* val)
	{
		return IAgilent34952ATotalize_get_Mode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Mode(BSTR ChannelList, Agilent34952ATotalizeThresholdModeEnum val)
	{
		return IAgilent34952ATotalize_put_Mode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ReadType(BSTR ChannelList, Agilent34952ATotalizeTypeEnum* val)
	{
		return IAgilent34952ATotalize_get_ReadType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ReadType(BSTR ChannelList, Agilent34952ATotalizeTypeEnum val)
	{
		return IAgilent34952ATotalize_put_ReadType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Slope(BSTR ChannelList, Agilent34952ATotalizeSlopeEnum* val)
	{
		return IAgilent34952ATotalize_get_Slope(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Slope(BSTR ChannelList, Agilent34952ATotalizeSlopeEnum val)
	{
		return IAgilent34952ATotalize_put_Slope(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34952ATotalize<Agilent34952A> _IAgilent34952ATotalize;




#endif // __FORWARDINGSHIMS_H__