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


typedef CPersonality<Agilent34945A, CVisaComIOProvider> DriverBase;

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

	return &_comparePolicyManager;
}

HRESULT IAgilent34945A_get_Channel(Agilent34945A* pT, IAgilent34945AChannel** val);
HRESULT IAgilent34945A_get_Module(Agilent34945A* pT, IAgilent34945AModule** val);
HRESULT IAgilent34945A_get_System(Agilent34945A* pT, IAgilent34945ASystem** val);
HRESULT IAgilent34945AChannel_Configure(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL Paired, VARIANT_BOOL PulseMode, double PulseWidth, double RecoveryTime, double SettleTime);
HRESULT IAgilent34945AChannel_Close(Agilent34945A* pT, BSTR ChannelList);
HRESULT IAgilent34945AChannel_Open(Agilent34945A* pT, BSTR ChannelList);
HRESULT IAgilent34945AChannel_get_DriveState(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34945AChannel_get_PairedMode(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34945AChannel_put_PairedMode(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34945AChannel_get_PulseMode(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34945AChannel_put_PulseMode(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34945AChannel_get_PulseWidth(Agilent34945A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34945AChannel_put_PulseWidth(Agilent34945A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34945AChannel_get_RecoveryTime(Agilent34945A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34945AChannel_put_RecoveryTime(Agilent34945A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34945AChannel_get_SettleTime(Agilent34945A* pT, BSTR ChannelList, double* val);
HRESULT IAgilent34945AChannel_put_SettleTime(Agilent34945A* pT, BSTR ChannelList, double val);
HRESULT IAgilent34945AChannel_get_VerificationEnable(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34945AChannel_put_VerificationEnable(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34945AChannel_get_VerificationPolarity(Agilent34945A* pT, BSTR ChannelList, Agilent34945APolarityEnum* val);
HRESULT IAgilent34945AChannel_put_VerificationPolarity(Agilent34945A* pT, BSTR ChannelList, Agilent34945APolarityEnum val);
HRESULT IAgilent34945AChannel_get_StateAtReset(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL* val);
HRESULT IAgilent34945AChannel_put_StateAtReset(Agilent34945A* pT, BSTR ChannelList, VARIANT_BOOL val);
HRESULT IAgilent34945AChannel_get_IsClosed(Agilent34945A* pT, BSTR Channel, VARIANT_BOOL* val);
HRESULT IAgilent34945AModule_BankPreset(Agilent34945A* pT, BSTR RemoteModuleList, long Bank);
HRESULT IAgilent34945AModule_get_BankDriveType(Agilent34945A* pT, BSTR RemoteModuleList, long Bank, Agilent34945ADriveTypeEnum* val);
HRESULT IAgilent34945AModule_put_BankDriveType(Agilent34945A* pT, BSTR RemoteModuleList, long Bank, Agilent34945ADriveTypeEnum val);
HRESULT IAgilent34945AModule_get_BankLEDEnable(Agilent34945A* pT, BSTR RemoteModuleList, long Bank, VARIANT_BOOL* val);
HRESULT IAgilent34945AModule_put_BankLEDEnable(Agilent34945A* pT, BSTR RemoteModuleList, long Bank, VARIANT_BOOL val);
HRESULT IAgilent34945AModule_get_BankLEDDriveLevel(Agilent34945A* pT, BSTR RemoteModuleList, long Bank, double* val);
HRESULT IAgilent34945AModule_put_BankLEDDriveLevel(Agilent34945A* pT, BSTR RemoteModuleList, long Bank, double val);
HRESULT IAgilent34945AModule_get_DriveChannelLimit(Agilent34945A* pT, BSTR RemoteModuleList, long* val);
HRESULT IAgilent34945AModule_put_DriveChannelLimit(Agilent34945A* pT, BSTR RemoteModuleList, long val);
HRESULT IAgilent34945AModule_get_DriveSource(Agilent34945A* pT, BSTR RemoteModuleList, Agilent34945ADriveSourceEnum* val);
HRESULT IAgilent34945AModule_put_DriveSource(Agilent34945A* pT, BSTR RemoteModuleList, Agilent34945ADriveSourceEnum val);
HRESULT IAgilent34945AModule_get_DriveSourceBootState(Agilent34945A* pT, BSTR RemoteModuleList, Agilent34945ADriveSourceEnum* val);
HRESULT IAgilent34945AModule_put_DriveSourceBootState(Agilent34945A* pT, BSTR RemoteModuleList, Agilent34945ADriveSourceEnum val);
HRESULT IAgilent34945ASystem_RemoteModuleReset(Agilent34945A* pT, long Slot);
HRESULT IAgilent34945ASystem_get_RemoteModuleDescription(Agilent34945A* pT, BSTR RemoteModule, long Bank, BSTR* val);
HRESULT IAgilent34945ASystem_get_RemoteModuleType(Agilent34945A* pT, BSTR RemoteModule, long Bank, BSTR* val);
HRESULT IAgilent34945ASystem_get_RemoteModuleStatus(Agilent34945A* pT, long Slot, BSTR* val);


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34945A
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34945A : public IAgilent34945A
{
	STDMETHODIMP get_Channel(IAgilent34945AChannel** val)
	{
		return IAgilent34945A_get_Channel(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_Module(IAgilent34945AModule** val)
	{
		return IAgilent34945A_get_Module(static_cast<Deriving*>(this), val);
	}
	STDMETHODIMP get_System(IAgilent34945ASystem** val)
	{
		return IAgilent34945A_get_System(static_cast<Deriving*>(this), val);
	}
};

typedef __IAgilent34945A<Agilent34945A> _IAgilent34945A;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34945AChannel
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34945AChannel : public IAgilent34945AChannel
{
	STDMETHODIMP Configure(BSTR ChannelList, VARIANT_BOOL Paired, VARIANT_BOOL PulseMode, double PulseWidth, double RecoveryTime, double SettleTime)
	{
		return IAgilent34945AChannel_Configure(static_cast<Deriving*>(this), ChannelList, Paired, PulseMode, PulseWidth, RecoveryTime, SettleTime);
	}
	STDMETHODIMP Close(BSTR ChannelList)
	{
		return IAgilent34945AChannel_Close(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP Open(BSTR ChannelList)
	{
		return IAgilent34945AChannel_Open(static_cast<Deriving*>(this), ChannelList);
	}
	STDMETHODIMP get_DriveState(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34945AChannel_get_DriveState(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_PairedMode(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34945AChannel_get_PairedMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_PairedMode(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34945AChannel_put_PairedMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_PulseMode(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34945AChannel_get_PulseMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_PulseMode(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34945AChannel_put_PulseMode(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_PulseWidth(BSTR ChannelList, double* val)
	{
		return IAgilent34945AChannel_get_PulseWidth(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_PulseWidth(BSTR ChannelList, double val)
	{
		return IAgilent34945AChannel_put_PulseWidth(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_RecoveryTime(BSTR ChannelList, double* val)
	{
		return IAgilent34945AChannel_get_RecoveryTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_RecoveryTime(BSTR ChannelList, double val)
	{
		return IAgilent34945AChannel_put_RecoveryTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_SettleTime(BSTR ChannelList, double* val)
	{
		return IAgilent34945AChannel_get_SettleTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_SettleTime(BSTR ChannelList, double val)
	{
		return IAgilent34945AChannel_put_SettleTime(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_VerificationEnable(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34945AChannel_get_VerificationEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_VerificationEnable(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34945AChannel_put_VerificationEnable(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_VerificationPolarity(BSTR ChannelList, Agilent34945APolarityEnum* val)
	{
		return IAgilent34945AChannel_get_VerificationPolarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_VerificationPolarity(BSTR ChannelList, Agilent34945APolarityEnum val)
	{
		return IAgilent34945AChannel_put_VerificationPolarity(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_StateAtReset(BSTR ChannelList, VARIANT_BOOL* val)
	{
		return IAgilent34945AChannel_get_StateAtReset(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP put_StateAtReset(BSTR ChannelList, VARIANT_BOOL val)
	{
		return IAgilent34945AChannel_put_StateAtReset(static_cast<Deriving*>(this), ChannelList, val);
	}
	STDMETHODIMP get_IsClosed(BSTR Channel, VARIANT_BOOL* val)
	{
		return IAgilent34945AChannel_get_IsClosed(static_cast<Deriving*>(this), Channel, val);
	}
};

typedef __IAgilent34945AChannel<Agilent34945A> _IAgilent34945AChannel;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34945AModule
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34945AModule : public IAgilent34945AModule
{
	STDMETHODIMP BankPreset(BSTR RemoteModuleList, long Bank)
	{
		return IAgilent34945AModule_BankPreset(static_cast<Deriving*>(this), RemoteModuleList, Bank);
	}
	STDMETHODIMP get_BankDriveType(BSTR RemoteModuleList, long Bank, Agilent34945ADriveTypeEnum* val)
	{
		return IAgilent34945AModule_get_BankDriveType(static_cast<Deriving*>(this), RemoteModuleList, Bank, val);
	}
	STDMETHODIMP put_BankDriveType(BSTR RemoteModuleList, long Bank, Agilent34945ADriveTypeEnum val)
	{
		return IAgilent34945AModule_put_BankDriveType(static_cast<Deriving*>(this), RemoteModuleList, Bank, val);
	}
	STDMETHODIMP get_BankLEDEnable(BSTR RemoteModuleList, long Bank, VARIANT_BOOL* val)
	{
		return IAgilent34945AModule_get_BankLEDEnable(static_cast<Deriving*>(this), RemoteModuleList, Bank, val);
	}
	STDMETHODIMP put_BankLEDEnable(BSTR RemoteModuleList, long Bank, VARIANT_BOOL val)
	{
		return IAgilent34945AModule_put_BankLEDEnable(static_cast<Deriving*>(this), RemoteModuleList, Bank, val);
	}
	STDMETHODIMP get_BankLEDDriveLevel(BSTR RemoteModuleList, long Bank, double* val)
	{
		return IAgilent34945AModule_get_BankLEDDriveLevel(static_cast<Deriving*>(this), RemoteModuleList, Bank, val);
	}
	STDMETHODIMP put_BankLEDDriveLevel(BSTR RemoteModuleList, long Bank, double val)
	{
		return IAgilent34945AModule_put_BankLEDDriveLevel(static_cast<Deriving*>(this), RemoteModuleList, Bank, val);
	}
	STDMETHODIMP get_DriveChannelLimit(BSTR RemoteModuleList, long* val)
	{
		return IAgilent34945AModule_get_DriveChannelLimit(static_cast<Deriving*>(this), RemoteModuleList, val);
	}
	STDMETHODIMP put_DriveChannelLimit(BSTR RemoteModuleList, long val)
	{
		return IAgilent34945AModule_put_DriveChannelLimit(static_cast<Deriving*>(this), RemoteModuleList, val);
	}
	STDMETHODIMP get_DriveSource(BSTR RemoteModuleList, Agilent34945ADriveSourceEnum* val)
	{
		return IAgilent34945AModule_get_DriveSource(static_cast<Deriving*>(this), RemoteModuleList, val);
	}
	STDMETHODIMP put_DriveSource(BSTR RemoteModuleList, Agilent34945ADriveSourceEnum val)
	{
		return IAgilent34945AModule_put_DriveSource(static_cast<Deriving*>(this), RemoteModuleList, val);
	}
	STDMETHODIMP get_DriveSourceBootState(BSTR RemoteModuleList, Agilent34945ADriveSourceEnum* val)
	{
		return IAgilent34945AModule_get_DriveSourceBootState(static_cast<Deriving*>(this), RemoteModuleList, val);
	}
	STDMETHODIMP put_DriveSourceBootState(BSTR RemoteModuleList, Agilent34945ADriveSourceEnum val)
	{
		return IAgilent34945AModule_put_DriveSourceBootState(static_cast<Deriving*>(this), RemoteModuleList, val);
	}
};

typedef __IAgilent34945AModule<Agilent34945A> _IAgilent34945AModule;


///////////////////////////////////////////////////////////////////////////////
//
//	IAgilent34945ASystem
//

template <typename Deriving> struct ATL_NO_VTABLE __IAgilent34945ASystem : public IAgilent34945ASystem
{
	STDMETHODIMP RemoteModuleReset(long Slot)
	{
		return IAgilent34945ASystem_RemoteModuleReset(static_cast<Deriving*>(this), Slot);
	}
	STDMETHODIMP get_RemoteModuleDescription(BSTR RemoteModule, long Bank, BSTR* val)
	{
		return IAgilent34945ASystem_get_RemoteModuleDescription(static_cast<Deriving*>(this), RemoteModule, Bank, val);
	}
	STDMETHODIMP get_RemoteModuleType(BSTR RemoteModule, long Bank, BSTR* val)
	{
		return IAgilent34945ASystem_get_RemoteModuleType(static_cast<Deriving*>(this), RemoteModule, Bank, val);
	}
	STDMETHODIMP get_RemoteModuleStatus(long Slot, BSTR* val)
	{
		return IAgilent34945ASystem_get_RemoteModuleStatus(static_cast<Deriving*>(this), Slot, val);
	}
};

typedef __IAgilent34945ASystem<Agilent34945A> _IAgilent34945ASystem;




#endif // __FORWARDINGSHIMS_H__