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


typedef CPersonality<Agilent34951A, CVisaComIOProvider> DriverBase;

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

	return &_comparePolicyManager;
}

HRESULT IAgilent34951A_get_Source(Agilent34951A* pT, IAgilent34951ASource** val);
HRESULT IAgilent34951A_get_Trace(Agilent34951A* pT, IAgilent34951ATrace** val);
HRESULT IAgilent34951A_get_Trigger(Agilent34951A* pT, IAgilent34951ATrigger** val);
HRESULT IAgilent34951A_get_Output(Agilent34951A* pT, IAgilent34951AOutput** val);
HRESULT IAgilent34951ACurrent_Configure(Agilent34951A* pT, BSTR ChannelList, double Level);
HRESULT IAgilent34951ACurrent_get_Level(Agilent34951A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34951ACurrent_put_Level(Agilent34951A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34951ACurrent_get_Gain(Agilent34951A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34951ACurrent_put_Gain(Agilent34951A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34951ACurrent_get_Offset(Agilent34951A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34951ACurrent_put_Offset(Agilent34951A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34951AOutput_get_State(Agilent34951A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34951AOutput_put_State(Agilent34951A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34951ASource_ApplyLevel(Agilent34951A* pT, BSTR ChannelList, Agilent34951AFunctionTypeEnum Function, double Level);
HRESULT IAgilent34951ASource_ApplyTrace(Agilent34951A* pT, BSTR ChannelList, BSTR TraceName, Agilent34951AFunctionTypeEnum Function, double Gain, double Offset, double Frequency);
HRESULT IAgilent34951ASource_ConfigureTrace(Agilent34951A* pT, BSTR ChannelList, Agilent34951AFunctionTypeEnum Function, BSTR TraceName, double Gain, double Offset);
HRESULT IAgilent34951ASource_StartTrace(Agilent34951A* pT, BSTR ChannelList, long NumCycles, long StartIndex);
HRESULT IAgilent34951ASource_HaltTrace(Agilent34951A* pT, BSTR ChannelList);
HRESULT IAgilent34951ASource_get_OperationMode(Agilent34951A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34951ASource_put_OperationMode(Agilent34951A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34951ASource_get_FunctionType(Agilent34951A* pT, BSTR ChannelList, Agilent34951AFunctionTypeEnum* val);
HRESULT IAgilent34951ASource_put_FunctionType(Agilent34951A* pT, BSTR ChannelList, Agilent34951AFunctionTypeEnum val);
HRESULT IAgilent34951ASource_get_NumCycles(Agilent34951A* pT, BSTR ChannelList, long* val);
HRESULT IAgilent34951ASource_put_NumCycles(Agilent34951A* pT, BSTR ChannelList, long val);
HRESULT IAgilent34951ASource_get_StartIndex(Agilent34951A* pT, BSTR ChannelLast, long* val);
HRESULT IAgilent34951ASource_put_StartIndex(Agilent34951A* pT, BSTR ChannelLast, long val);
HRESULT IAgilent34951ASource_get_TraceName(Agilent34951A* pT, BSTR ChannelList, BSTR* val);
HRESULT IAgilent34951ASource_put_TraceName(Agilent34951A* pT, BSTR ChannelList, BSTR val);
HRESULT IAgilent34951ASource_get_Frequency(Agilent34951A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34951ASource_put_Frequency(Agilent34951A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34951ASource_get_Current(Agilent34951A* pT, IAgilent34951ACurrent** val);
HRESULT IAgilent34951ASource_get_Voltage(Agilent34951A* pT, IAgilent34951AVoltage** val);
HRESULT IAgilent34951ATrace_CreateCustomInteger(Agilent34951A* pT, long SlotNumber, BSTR Name, long Points, SAFEARRAY** DataArray);
HRESULT IAgilent34951ATrace_CreateCustomFloat(Agilent34951A* pT, long SlotNumber, BSTR Name, long NumPoints, SAFEARRAY** DataArray);
HRESULT IAgilent34951ATrace_CreateStandard(Agilent34951A* pT, long SlotNumber, BSTR Name, long Points, Agilent34951ATraceWaveformEnum Type);
HRESULT IAgilent34951ATrace_Delete(Agilent34951A* pT, long SlotNumber, BSTR TraceName);
HRESULT IAgilent34951ATrace_DeleteAll(Agilent34951A* pT, long SlotNumber);
HRESULT IAgilent34951ATrace_CreateCustomFromFile(Agilent34951A* pT, long SlotNumber, BSTR Name, BSTR SourceFile);
HRESULT IAgilent34951ATrace_get_Points(Agilent34951A* pT, long SlotNumber, BSTR Name, long* val);
HRESULT IAgilent34951ATrace_get_MemoryFree(Agilent34951A* pT, long SlotNumber, long* val);
HRESULT IAgilent34951ATrace_get_Catalog(Agilent34951A* pT, long SlotNumber, BSTR* val);
HRESULT IAgilent34951ATrigger_ConfigureInternalPacing(Agilent34951A* pT, BSTR ChannelList, Agilent34951ATraceTriggerSourceEnum TriggerSource, double Period);
HRESULT IAgilent34951ATrigger_ConfigureExternalPacing(Agilent34951A* pT, BSTR ChannelList, Agilent34951ATraceTriggerSourceEnum TriggerSource, long Divisor);
HRESULT IAgilent34951ATrigger_TriggerImmediate(Agilent34951A* pT, BSTR ChannelList);
HRESULT IAgilent34951ATrigger_get_Source(Agilent34951A* pT, BSTR ChannelList, Agilent34951ATraceTriggerSourceEnum* val);
HRESULT IAgilent34951ATrigger_put_Source(Agilent34951A* pT, BSTR ChannelList, Agilent34951ATraceTriggerSourceEnum val);
HRESULT IAgilent34951ATrigger_get_ClockSource(Agilent34951A* pT, BSTR ChannelList, Agilent34951AClockSourceEnum* val);
HRESULT IAgilent34951ATrigger_put_ClockSource(Agilent34951A* pT, BSTR ChannelList, Agilent34951AClockSourceEnum val);
HRESULT IAgilent34951ATrigger_get_ClockPeriod(Agilent34951A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34951ATrigger_put_ClockPeriod(Agilent34951A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34951AVoltage_Configure(Agilent34951A* pT, BSTR ChannelList, double Level);
HRESULT IAgilent34951AVoltage_get_Gain(Agilent34951A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34951AVoltage_put_Gain(Agilent34951A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34951AVoltage_get_Level(Agilent34951A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34951AVoltage_put_Level(Agilent34951A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34951AVoltage_get_Offset(Agilent34951A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34951AVoltage_put_Offset(Agilent34951A* pT, BSTR ChannelList, double val);


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34951A
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34951A : public IAgilent34951A
{
	STDMETHODIMP get_Source(IAgilent34951ASource** val)
	{
		return IAgilent34951A_get_Source(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Trace(IAgilent34951ATrace** val)
	{
		return IAgilent34951A_get_Trace(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Trigger(IAgilent34951ATrigger** val)
	{
		return IAgilent34951A_get_Trigger(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Output(IAgilent34951AOutput** val)
	{
		return IAgilent34951A_get_Output(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34951A<Agilent34951A> _IAgilent34951A;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34951ACurrent
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34951ACurrent : public IAgilent34951ACurrent
{
	STDMETHODIMP Configure(BSTR ChannelList, double Level)
	{
		return IAgilent34951ACurrent_Configure(static_cast<Deriving*>(this), ChannelList, Level);
	}
	STDMETHODIMP get_Level(BSTR ChannelList, double* val)
	{
		return IAgilent34951ACurrent_get_Level(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Level(BSTR ChannelList, double val)
	{
		return IAgilent34951ACurrent_put_Level(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Gain(BSTR ChannelList, double* val)
	{
		return IAgilent34951ACurrent_get_Gain(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Gain(BSTR ChannelList, double val)
	{
		return IAgilent34951ACurrent_put_Gain(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Offset(BSTR ChannelList, double* val)
	{
		return IAgilent34951ACurrent_get_Offset(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Offset(BSTR ChannelList, double val)
	{
		return IAgilent34951ACurrent_put_Offset(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34951ACurrent<Agilent34951A> _IAgilent34951ACurrent;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34951AOutput
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34951AOutput : public IAgilent34951AOutput
{
	STDMETHODIMP get_State(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34951AOutput_get_State(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_State(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34951AOutput_put_State(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34951AOutput<Agilent34951A> _IAgilent34951AOutput;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34951ASource
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34951ASource : public IAgilent34951ASource
{
	STDMETHODIMP ApplyLevel(BSTR ChannelList, Agilent34951AFunctionTypeEnum Function, double Level)
	{
		return IAgilent34951ASource_ApplyLevel(static_cast<Deriving*>(this), ChannelList, Function, Level);
	}
	STDMETHODIMP ApplyTrace(BSTR ChannelList, BSTR TraceName, Agilent34951AFunctionTypeEnum Function, double Gain, double Offset, double Frequency)
	{
		return IAgilent34951ASource_ApplyTrace(static_cast<Deriving*>(this), ChannelList, TraceName, Function, Gain, Offset, Frequency);
	}
	STDMETHODIMP ConfigureTrace(BSTR ChannelList, Agilent34951AFunctionTypeEnum Function, BSTR TraceName, double Gain, double Offset)
	{
		return IAgilent34951ASource_ConfigureTrace(static_cast<Deriving*>(this), ChannelList, Function, TraceName, Gain, Offset);
	}
	STDMETHODIMP StartTrace(BSTR ChannelList, long NumCycles, long StartIndex)
	{
		return IAgilent34951ASource_StartTrace(static_cast<Deriving*>(this), ChannelList, NumCycles, StartIndex);
	}
	STDMETHODIMP HaltTrace(BSTR ChannelList)
	{
		return IAgilent34951ASource_HaltTrace(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP get_OperationMode(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34951ASource_get_OperationMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_OperationMode(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34951ASource_put_OperationMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_FunctionType(BSTR ChannelList, Agilent34951AFunctionTypeEnum* val)
	{
		return IAgilent34951ASource_get_FunctionType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_FunctionType(BSTR ChannelList, Agilent34951AFunctionTypeEnum val)
	{
		return IAgilent34951ASource_put_FunctionType(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_NumCycles(BSTR ChannelList, long* val)
	{
		return IAgilent34951ASource_get_NumCycles(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_NumCycles(BSTR ChannelList, long val)
	{
		return IAgilent34951ASource_put_NumCycles(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_StartIndex(BSTR ChannelLast, long* val)
	{
		return IAgilent34951ASource_get_StartIndex(static_cast<Deriving*>(this), ChannelLast, val);
	}
	STDMETHODIMP put_StartIndex(BSTR ChannelLast, long val)
	{
		return IAgilent34951ASource_put_StartIndex(static_cast<Deriving*>(this), ChannelLast, val);
	}
	STDMETHODIMP get_TraceName(BSTR ChannelList, BSTR* val)
	{
		return IAgilent34951ASource_get_TraceName(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_TraceName(BSTR ChannelList, BSTR val)
	{
		return IAgilent34951ASource_put_TraceName(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Frequency(BSTR ChannelList, double* val)
	{
		return IAgilent34951ASource_get_Frequency(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Frequency(BSTR ChannelList, double val)
	{
		return IAgilent34951ASource_put_Frequency(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Current(IAgilent34951ACurrent** val)
	{
		return IAgilent34951ASource_get_Current(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Voltage(IAgilent34951AVoltage** val)
	{
		return IAgilent34951ASource_get_Voltage(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34951ASource<Agilent34951A> _IAgilent34951ASource;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34951ATrace
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34951ATrace : public IAgilent34951ATrace
{
	STDMETHODIMP CreateCustomInteger(long SlotNumber, BSTR Name, long Points, SAFEARRAY** DataArray)
	{
		return IAgilent34951ATrace_CreateCustomInteger(static_cast<Deriving*>(this), SlotNumber, Name, Points, DataArray);
	}
	STDMETHODIMP CreateCustomFloat(long SlotNumber, BSTR Name, long NumPoints, SAFEARRAY** DataArray)
	{
		return IAgilent34951ATrace_CreateCustomFloat(static_cast<Deriving*>(this), SlotNumber, Name, NumPoints, DataArray);
	}
	STDMETHODIMP CreateStandard(long SlotNumber, BSTR Name, long Points, Agilent34951ATraceWaveformEnum Type)
	{
		return IAgilent34951ATrace_CreateStandard(static_cast<Deriving*>(this), SlotNumber, Name, Points, Type);
	}
	STDMETHODIMP Delete(long SlotNumber, BSTR TraceName)
	{
		return IAgilent34951ATrace_Delete(static_cast<Deriving*>(this), SlotNumber, TraceName);
	}
	STDMETHODIMP DeleteAll(long SlotNumber)
	{
		return IAgilent34951ATrace_DeleteAll(static_cast<Deriving*>(this), SlotNumber);
	}
	STDMETHODIMP CreateCustomFromFile(long SlotNumber, BSTR Name, BSTR SourceFile)
	{
		return IAgilent34951ATrace_CreateCustomFromFile(static_cast<Deriving*>(this), SlotNumber, Name, SourceFile);
	}
	STDMETHODIMP get_Points(long SlotNumber, BSTR Name, long* val)
	{
		return IAgilent34951ATrace_get_Points(static_cast<Deriving*>(this), SlotNumber, Name, val);
	}
	STDMETHODIMP get_MemoryFree(long SlotNumber, long* val)
	{
		return IAgilent34951ATrace_get_MemoryFree(static_cast<Deriving*>(this), SlotNumber, val);
	}
	STDMETHODIMP get_Catalog(long SlotNumber, BSTR* val)
	{
		return IAgilent34951ATrace_get_Catalog(static_cast<Deriving*>(this), SlotNumber, val);
	}
};

typedef __IAgilent34951ATrace<Agilent34951A> _IAgilent34951ATrace;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34951ATrigger
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34951ATrigger : public IAgilent34951ATrigger
{
	STDMETHODIMP ConfigureInternalPacing(BSTR ChannelList, Agilent34951ATraceTriggerSourceEnum TriggerSource, double Period)
	{
		return IAgilent34951ATrigger_ConfigureInternalPacing(static_cast<Deriving*>(this), ChannelList, TriggerSource, Period);
	}
	STDMETHODIMP ConfigureExternalPacing(BSTR ChannelList, Agilent34951ATraceTriggerSourceEnum TriggerSource, long Divisor)
	{
		return IAgilent34951ATrigger_ConfigureExternalPacing(static_cast<Deriving*>(this), ChannelList, TriggerSource, Divisor);
	}
	STDMETHODIMP TriggerImmediate(BSTR ChannelList)
	{
		return IAgilent34951ATrigger_TriggerImmediate(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP get_Source(BSTR ChannelList, Agilent34951ATraceTriggerSourceEnum* val)
	{
		return IAgilent34951ATrigger_get_Source(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Source(BSTR ChannelList, Agilent34951ATraceTriggerSourceEnum val)
	{
		return IAgilent34951ATrigger_put_Source(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ClockSource(BSTR ChannelList, Agilent34951AClockSourceEnum* val)
	{
		return IAgilent34951ATrigger_get_ClockSource(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ClockSource(BSTR ChannelList, Agilent34951AClockSourceEnum val)
	{
		return IAgilent34951ATrigger_put_ClockSource(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_ClockPeriod(BSTR ChannelList, double* val)
	{
		return IAgilent34951ATrigger_get_ClockPeriod(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_ClockPeriod(BSTR ChannelList, double val)
	{
		return IAgilent34951ATrigger_put_ClockPeriod(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34951ATrigger<Agilent34951A> _IAgilent34951ATrigger;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34951AVoltage
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34951AVoltage : public IAgilent34951AVoltage
{
	STDMETHODIMP Configure(BSTR ChannelList, double Level)
	{
		return IAgilent34951AVoltage_Configure(static_cast<Deriving*>(this), ChannelList, Level);
	}
	STDMETHODIMP get_Gain(BSTR ChannelList, double* val)
	{
		return IAgilent34951AVoltage_get_Gain(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Gain(BSTR ChannelList, double val)
	{
		return IAgilent34951AVoltage_put_Gain(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Level(BSTR ChannelList, double* val)
	{
		return IAgilent34951AVoltage_get_Level(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Level(BSTR ChannelList, double val)
	{
		return IAgilent34951AVoltage_put_Level(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_Offset(BSTR ChannelList, double* val)
	{
		return IAgilent34951AVoltage_get_Offset(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_Offset(BSTR ChannelList, double val)
	{
		return IAgilent34951AVoltage_put_Offset(static_cast<Deriving*>(this), ChannelList, val);
	}
};

typedef __IAgilent34951AVoltage<Agilent34951A> _IAgilent34951AVoltage;




#endif // __FORWARDINGSHIMS_H__