sshwbemhelpers.h

希望我上传的这些东西可以对搞编程的程序员有点小小的帮助！谢谢！

		
		hr = m_pWbemObject->Next(0,&bstr,&_value,NULL,NULL);
		
		if(hr == S_OK)
		{
			_sName = _bstr_t(bstr,false);
		}
		
		return hr;
	}
	
	HRESULT Next(_bstr_t& _sName,_variant_t& _value,CIMTYPE& _vartype)
	{
		HRESULT     hr;
		BSTR        bstr = NULL;
		
		_value.Clear();
		hr = m_pWbemObject->Next(0,&bstr,&_value,&_vartype,NULL);
		
		if(hr == S_OK)
		{
			_sName = _bstr_t(bstr,false);
		}
		
		return hr;
	}
	
	HRESULT Next(_bstr_t& _sName,_variant_t& _value,CIMTYPE& _vartype,long& _flavor)
	{
		HRESULT     hr;
		BSTR        bstr = NULL;
		
		_value.Clear();
		hr = m_pWbemObject->Next(0,&bstr,&_value,&_vartype,&_flavor);
		
		if(hr == S_OK)
		{
			_sName = _bstr_t(bstr,false);
		}
		
		return hr;
	}
	
	HRESULT EndEnumeration()
	{
		return m_pWbemObject->EndEnumeration();
	}
	
};


// these operators are needed for storage in some data structures
__inline bool operator<(const CWbemClassObject& _X, const CWbemClassObject& _Y) 
{
	return _X < _Y;
}

__inline bool operator==(const CWbemClassObject& _X, const CWbemClassObject& _Y)
{
	return _X == _Y;
}



//-----------------------------------------------------------------------------
// CWbemServices
//
//  Provides thread safe encapsulation of the IWbemServices interface and provides
//  access to it's methods. See the IWbemServices documentation for information 
//  about the methods.
//
//  This clas also encapsulates IWbemLocator::ConnectServer(). When using this call, 
//	 provide the address of a NULL IWbemServices pointer to act as a cache. This class
//  actually stores the interface pointer in an IStream. A real interface needs
//  to be kept somewhere or DCOM will garbage collect the object. When the instance
//  of this class is deleted, the cached pointer still needs to be released. Use a
//  smart pointer (IWbemServicesPtr) and keep it in the same scope as the 
//  CWbemServices instance.
//

class CWbemServices 
{
private:
	IWbemContextPtr     m_pCtx;
	IStream *           m_pServicesStream; // encapsulated IWbemServices pointer
	IUnknownPtr         m_pUnkCache;
	CRITICAL_SECTION    m_cs;
	
	bool GetInterfacePtr(IWbemServicesPtr & pServices,bool bThrowException = true);
	void CommonInit(IWbemServicesPtr& pServ);
	
public:
	// constructors will AddRef the pointer
	CWbemServices(IWbemContext * _pContext = NULL);
	CWbemServices(const CWbemServices& _p);
	CWbemServices(const IWbemServicesPtr& _in);
	CWbemServices(const IUnknownPtr& _in);
	CWbemServices(IUnknown * _in);
	CWbemServices(IWbemServices *_in,IWbemContext * _pContext = NULL);
	~CWbemServices();
	
	CWbemServices& operator=(IUnknown * _p);
	CWbemServices& operator=(IUnknownPtr& _p);
	CWbemServices& operator=(IWbemServices *_p);
	CWbemServices& operator=(const CWbemServices& _p);
	
	// when logging in, capture the IWbemServices pointer and keep it somewhere
	// this pointer is stored internaly in an IStream and DCOM will garbage collect the object if
	// there isn't at least one reference to it

	// Login with integrated security
	void ConnectServer(_bstr_t sNetworkResource, IWbemServices **_WbemServicesCache) throw(CWbemException);
	
	// Login as a specific user
	void ConnectServer
		(
		_bstr_t sNetworkResource,
		_bstr_t sUser,
		_bstr_t sPassword,
		IWbemServices **_WbemServicesCache,
		long    lSecurityFlags = 0
		) throw(CWbemException);
	
	
	// create an instance a of a class given the class name
	// encapsulates GetObject and SpawnInstance
	CWbemClassObject CreateInstance
		(
		_bstr_t             _sClassName,
		IWbemCallResultPtr& _cr
		)
	{
		CWbemClassObject coClassDef = GetObject(_sClassName,_cr);
		CWbemClassObject coRet;
		
		if(!coClassDef.IsNull())
		{
			coRet = coClassDef.SpawnInstance();
		}
		
		return coRet;
	}
	
	CWbemClassObject CreateInstance(_bstr_t _sClassName)
	{
		IWbemCallResultPtr crUnused;
		return CreateInstance(_sClassName,crUnused);
	}
	
	HRESULT DeleteInstance
		(
		_bstr_t             _sClass, 
		IWbemCallResultPtr& _cr
		)
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->DeleteInstance(_sClass, 0, m_pCtx, &_cr);
		return hr;
	}
	
	HRESULT DeleteInstance(_bstr_t _sClass)
	{
		IWbemCallResultPtr crUnused;
		return DeleteInstance(_sClass, crUnused);
	}
	
	CWbemClassObject GetObject
		(
		_bstr_t                 _sName,
		IWbemCallResultPtr&     _cr,
		bool                    _bThrowOnError = false
		);
	
	CWbemClassObject GetObject(_bstr_t _sName,bool _bThrowOnError = false)
	{
		IWbemCallResultPtr crUnused;
		return GetObject(_sName,crUnused,_bThrowOnError);
	}
	
	
	HRESULT GetMethodSignatures(const _bstr_t& _sObjectName,const _bstr_t& _sMethodName,CWbemClassObject& _in,CWbemClassObject& _out)
	{
		HRESULT hr = E_FAIL;
		
		CWbemClassObject methodClass = GetObject(_sObjectName);
		
		if(methodClass)
		{
			hr = methodClass.GetMethod(_sMethodName,_in,_out);
		}
		
		return hr;
	}
	
	
	HRESULT PutInstance
		(
		CWbemClassObject&   _object,
		IWbemCallResultPtr& _cr,
		long                _lFlags = WBEM_FLAG_CREATE_OR_UPDATE
		)
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->PutInstance(_object,_lFlags,m_pCtx,&_cr);
		return hr;
	}
	
	HRESULT PutInstance
		(
		CWbemClassObject&   _object,
		long                _lFlags = WBEM_FLAG_CREATE_OR_UPDATE
		)
	{
		IWbemCallResultPtr crUnused;
		return PutInstance(_object,crUnused,_lFlags);
	}
	
	bool IsNull() 
	{  
		IWbemServicesPtr pServices;
		bool bRet = GetInterfacePtr(pServices,false) == NULL;
		
		return bRet;
	}
	
	operator bool()
	{
		IWbemServicesPtr pServices;
		bool bRet = GetInterfacePtr(pServices,false) != NULL;
		return bRet;
	}

	operator !()
	{
		IWbemServicesPtr pServices;
		bool bRet = GetInterfacePtr(pServices,false) == NULL;
		return bRet;
	}

	
	HRESULT CreateInstanceEnum
		(
		_bstr_t Class, 
		long lFlags, 
		IEnumWbemClassObject **ppEnum
		)
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->CreateInstanceEnum(Class, lFlags, m_pCtx, ppEnum);
		return hr;
	}
	
	
	HRESULT CreateInstanceEnumAsync
		(
		_bstr_t Class, 
		IWbemObjectSink * ppSink,
		long lFlags = 0
		)
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->CreateInstanceEnumAsync(Class, lFlags, m_pCtx, ppSink);
		return hr;
	}
	
	
	HRESULT CreateClassEnum
		(
		_bstr_t Class, 
		long lFlags, 
		IEnumWbemClassObject **ppEnum
		)
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->CreateClassEnum(Class, lFlags, m_pCtx, ppEnum);
		return hr;
	}
	
	HRESULT ExecQuery
		(
		_bstr_t QueryLanguage,
		_bstr_t Query,
		long lFlags,
		IEnumWbemClassObject **ppEnum
		) 
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->ExecQuery(QueryLanguage, Query,lFlags, m_pCtx, ppEnum);
		return hr;
	}
	
	HRESULT ExecQuery
		(
		_bstr_t Query,
		long lFlags,
		IEnumWbemClassObject **ppEnum
		) 
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->ExecQuery(_bstr_t("WQL"), Query,lFlags, m_pCtx, ppEnum);
		return hr;
	}
	
	HRESULT ExecQuery
		(
		_bstr_t Query,
		IEnumWbemClassObject **ppEnum
		) 
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->ExecQuery(_bstr_t("WQL"), Query,0, m_pCtx, ppEnum);
		return hr;
	}
	
	
	
	HRESULT ExecQueryAsync
		(
		_bstr_t Query,
		IWbemObjectSink * pSink,
		long lFlags = 0
		)
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->ExecQueryAsync(_bstr_t("WQL"), Query,0, m_pCtx, pSink);
		return hr;
	}
	
	
	HRESULT ExecMethod
		(
		_bstr_t sPath,
		_bstr_t sMethod,
		CWbemClassObject& inParams,
		CWbemClassObject& outParams
		)
	{
		IWbemCallResultPtr crUnused;
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->ExecMethod(sPath, sMethod,0, m_pCtx, inParams,&outParams,&crUnused);
		return hr;
	}
	
	HRESULT CancelAsyncCall(IWbemObjectSink * pSink)
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		HRESULT hr = pServices->CancelAsyncCall(pSink);
		return hr;
	}
	
	// context values are stored and used for every call until cleared
	HRESULT SetContextValue(_bstr_t sName,_variant_t value);
	HRESULT GetContextValue(_bstr_t sName,_variant_t& value);
	HRESULT DeleteContextValue(_bstr_t sName);
	HRESULT DeleteAllContextValues();
	HRESULT SetContext(IWbemContext * pWbemContext);
	HRESULT GetContext(IWbemContext ** ppWbemContext);
	
	HRESULT GetServices(IWbemServices ** ppServices)
	{
		IWbemServicesPtr pServices;
		GetInterfacePtr(pServices);
		
		*ppServices = pServices.Detach();
		
		return S_OK;
	}
	
};


#pragma option pop /*P_O_Pop*/
#endif //__SdkWbemHelpers_H