📄 086f0db0163945b.h

📁 一个温度转换的程序
💻 H
字号:
//
// sproxy.exe generated file
// do not modify this file
//
// Created: 01/07/2008@15:53:41
//

#pragma once


#ifndef _WIN32_WINDOWS
#pragma message("warning: defining _WIN32_WINDOWS = 0x0410")
#define _WIN32_WINDOWS 0x0410
#endif

#include <atlsoap.h>

namespace TempConvert4Service
{

template <typename TClient = CSoapSocketClientT<> >
class CTempConvert4ServiceT : 
	public TClient, 
	public CSoapRootHandler
{
protected:

	const _soapmap ** GetFunctionMap();
	const _soapmap ** GetHeaderMap();
	void * GetHeaderValue();
	const wchar_t * GetNamespaceUri();
	const char * GetServiceName();
	const char * GetNamespaceUriA();
	HRESULT CallFunction(
		void *pvParam, 
		const wchar_t *wszLocalName, int cchLocalName,
		size_t nItem);
	HRESULT GetClientReader(ISAXXMLReader **ppReader);

public:

	HRESULT __stdcall QueryInterface(REFIID riid, void **ppv)
	{
		if (ppv == NULL)
		{
			return E_POINTER;
		}

		*ppv = NULL;

		if (InlineIsEqualGUID(riid, IID_IUnknown) ||
			InlineIsEqualGUID(riid, IID_ISAXContentHandler))
		{
			*ppv = static_cast<ISAXContentHandler *>(this);
			return S_OK;
		}

		return E_NOINTERFACE;
	}

	ULONG __stdcall AddRef()
	{
		return 1;
	}

	ULONG __stdcall Release()
	{
		return 1;
	}

	CTempConvert4ServiceT(ISAXXMLReader *pReader = NULL)
		:TClient(_T("http://086f0db0163945b:80/TempConvert4/TempConvert4.dll\?Handler=Default"))
	{
		SetClient(true);
		SetReader(pReader);
	}
	
	~CTempConvert4ServiceT()
	{
		Uninitialize();
	}
	
	void Uninitialize()
	{
		UninitializeSOAP();
	}	

	HRESULT ConvertC2F(
		double dFahrenheit, 
		double* __retval
	);

	HRESULT ConvertF2C(
		double dFahrenheit, 
		double* __retval
	);

	HRESULT HelloWorld(
		BSTR bstrInput, 
		BSTR* __retval
	);
};

typedef CTempConvert4ServiceT<> CTempConvert4Service;

struct __CTempConvert4Service_ConvertC2F_struct
{
	double dFahrenheit;
	double __retval;
};

extern __declspec(selectany) const _soapmapentry __CTempConvert4Service_ConvertC2F_entries[] =
{

	{
		0x8C092922, 
		"dFahrenheit", 
		L"dFahrenheit", 
		sizeof("dFahrenheit")-1, 
		SOAPTYPE_DOUBLE, 
		SOAPFLAG_NONE | SOAPFLAG_IN | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
		offsetof(__CTempConvert4Service_ConvertC2F_struct, dFahrenheit),
		NULL,
		NULL,
		-1,
	},
	{
		0x11515F60, 
		"return", 
		L"return", 
		sizeof("return")-1, 
		SOAPTYPE_DOUBLE, 
		SOAPFLAG_NONE | SOAPFLAG_OUT | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
		offsetof(__CTempConvert4Service_ConvertC2F_struct, __retval),
		NULL,
		NULL,
		-1,
	},
	{ 0x00000000 }
};

extern __declspec(selectany) const _soapmap __CTempConvert4Service_ConvertC2F_map =
{
	0x8443255C,
	"ConvertC2F",
	L"ConvertC2F",
	sizeof("ConvertC2F")-1,
	sizeof("ConvertC2F")-1,
	SOAPMAP_FUNC,
	__CTempConvert4Service_ConvertC2F_entries,
	sizeof(__CTempConvert4Service_ConvertC2F_struct),
	1,
	-1,
	SOAPFLAG_NONE | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
	0xAABE508B,
	"urn:TempConvert4Service",
	L"urn:TempConvert4Service",
	sizeof("urn:TempConvert4Service")-1
};


struct __CTempConvert4Service_ConvertF2C_struct
{
	double dFahrenheit;
	double __retval;
};

extern __declspec(selectany) const _soapmapentry __CTempConvert4Service_ConvertF2C_entries[] =
{

	{
		0x8C092922, 
		"dFahrenheit", 
		L"dFahrenheit", 
		sizeof("dFahrenheit")-1, 
		SOAPTYPE_DOUBLE, 
		SOAPFLAG_NONE | SOAPFLAG_IN | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
		offsetof(__CTempConvert4Service_ConvertF2C_struct, dFahrenheit),
		NULL,
		NULL,
		-1,
	},
	{
		0x11515F60, 
		"return", 
		L"return", 
		sizeof("return")-1, 
		SOAPTYPE_DOUBLE, 
		SOAPFLAG_NONE | SOAPFLAG_OUT | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
		offsetof(__CTempConvert4Service_ConvertF2C_struct, __retval),
		NULL,
		NULL,
		-1,
	},
	{ 0x00000000 }
};

extern __declspec(selectany) const _soapmap __CTempConvert4Service_ConvertF2C_map =
{
	0x8443321C,
	"ConvertF2C",
	L"ConvertF2C",
	sizeof("ConvertF2C")-1,
	sizeof("ConvertF2C")-1,
	SOAPMAP_FUNC,
	__CTempConvert4Service_ConvertF2C_entries,
	sizeof(__CTempConvert4Service_ConvertF2C_struct),
	1,
	-1,
	SOAPFLAG_NONE | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
	0xAABE508B,
	"urn:TempConvert4Service",
	L"urn:TempConvert4Service",
	sizeof("urn:TempConvert4Service")-1
};


struct __CTempConvert4Service_HelloWorld_struct
{
	BSTR bstrInput;
	BSTR __retval;
};

extern __declspec(selectany) const _soapmapentry __CTempConvert4Service_HelloWorld_entries[] =
{

	{
		0xA9ECBD0B, 
		"bstrInput", 
		L"bstrInput", 
		sizeof("bstrInput")-1, 
		SOAPTYPE_STRING, 
		SOAPFLAG_NONE | SOAPFLAG_IN | SOAPFLAG_RPC | SOAPFLAG_ENCODED | SOAPFLAG_NULLABLE,
		offsetof(__CTempConvert4Service_HelloWorld_struct, bstrInput),
		NULL,
		NULL,
		-1,
	},
	{
		0x11515F60, 
		"return", 
		L"return", 
		sizeof("return")-1, 
		SOAPTYPE_STRING, 
		SOAPFLAG_NONE | SOAPFLAG_OUT | SOAPFLAG_RPC | SOAPFLAG_ENCODED | SOAPFLAG_NULLABLE,
		offsetof(__CTempConvert4Service_HelloWorld_struct, __retval),
		NULL,
		NULL,
		-1,
	},
	{ 0x00000000 }
};

extern __declspec(selectany) const _soapmap __CTempConvert4Service_HelloWorld_map =
{
	0x46BA99FC,
	"HelloWorld",
	L"HelloWorld",
	sizeof("HelloWorld")-1,
	sizeof("HelloWorld")-1,
	SOAPMAP_FUNC,
	__CTempConvert4Service_HelloWorld_entries,
	sizeof(__CTempConvert4Service_HelloWorld_struct),
	1,
	-1,
	SOAPFLAG_NONE | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
	0xAABE508B,
	"urn:TempConvert4Service",
	L"urn:TempConvert4Service",
	sizeof("urn:TempConvert4Service")-1
};

extern __declspec(selectany) const _soapmap * __CTempConvert4Service_funcs[] =
{
	&__CTempConvert4Service_ConvertC2F_map,
	&__CTempConvert4Service_ConvertF2C_map,
	&__CTempConvert4Service_HelloWorld_map,
	NULL
};

template <typename TClient>
inline HRESULT CTempConvert4ServiceT<TClient>::ConvertC2F(
		double dFahrenheit, 
		double* __retval
	)
{
    if ( __retval == NULL )
		return E_POINTER;

	HRESULT __atlsoap_hr = InitializeSOAP(NULL);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_INITIALIZE_ERROR);
		return __atlsoap_hr;
	}
	
	CleanupClient();

	CComPtr<IStream> __atlsoap_spReadStream;
	__CTempConvert4Service_ConvertC2F_struct __params;
	memset(&__params, 0x00, sizeof(__params));
	__params.dFahrenheit = dFahrenheit;

	__atlsoap_hr = SetClientStruct(&__params, 0);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_OUTOFMEMORY);
		goto __skip_cleanup;
	}
	
	__atlsoap_hr = GenerateResponse(GetWriteStream());
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_GENERATE_ERROR);
		goto __skip_cleanup;
	}
	
	__atlsoap_hr = SendRequest(_T("SOAPAction: \"#ConvertC2F\"\r\n"));
	if (FAILED(__atlsoap_hr))
	{
		goto __skip_cleanup;
	}
	__atlsoap_hr = GetReadStream(&__atlsoap_spReadStream);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_READ_ERROR);
		goto __skip_cleanup;
	}
	
	// cleanup any in/out-params and out-headers from previous calls
	Cleanup();
	__atlsoap_hr = BeginParse(__atlsoap_spReadStream);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_PARSE_ERROR);
		goto __cleanup;
	}

	*__retval = __params.__retval;
	goto __skip_cleanup;
	
__cleanup:
	Cleanup();
__skip_cleanup:
	ResetClientState(true);
	memset(&__params, 0x00, sizeof(__params));
	return __atlsoap_hr;
}

template <typename TClient>
inline HRESULT CTempConvert4ServiceT<TClient>::ConvertF2C(
		double dFahrenheit, 
		double* __retval
	)
{
    if ( __retval == NULL )
		return E_POINTER;

	HRESULT __atlsoap_hr = InitializeSOAP(NULL);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_INITIALIZE_ERROR);
		return __atlsoap_hr;
	}
	
	CleanupClient();

	CComPtr<IStream> __atlsoap_spReadStream;
	__CTempConvert4Service_ConvertF2C_struct __params;
	memset(&__params, 0x00, sizeof(__params));
	__params.dFahrenheit = dFahrenheit;

	__atlsoap_hr = SetClientStruct(&__params, 1);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_OUTOFMEMORY);
		goto __skip_cleanup;
	}
	
	__atlsoap_hr = GenerateResponse(GetWriteStream());
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_GENERATE_ERROR);
		goto __skip_cleanup;
	}
	
	__atlsoap_hr = SendRequest(_T("SOAPAction: \"#ConvertF2C\"\r\n"));
	if (FAILED(__atlsoap_hr))
	{
		goto __skip_cleanup;
	}
	__atlsoap_hr = GetReadStream(&__atlsoap_spReadStream);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_READ_ERROR);
		goto __skip_cleanup;
	}
	
	// cleanup any in/out-params and out-headers from previous calls
	Cleanup();
	__atlsoap_hr = BeginParse(__atlsoap_spReadStream);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_PARSE_ERROR);
		goto __cleanup;
	}

	*__retval = __params.__retval;
	goto __skip_cleanup;
	
__cleanup:
	Cleanup();
__skip_cleanup:
	ResetClientState(true);
	memset(&__params, 0x00, sizeof(__params));
	return __atlsoap_hr;
}

template <typename TClient>
inline HRESULT CTempConvert4ServiceT<TClient>::HelloWorld(
		BSTR bstrInput, 
		BSTR* __retval
	)
{
    if ( __retval == NULL )
		return E_POINTER;

	HRESULT __atlsoap_hr = InitializeSOAP(NULL);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_INITIALIZE_ERROR);
		return __atlsoap_hr;
	}
	
	CleanupClient();

	CComPtr<IStream> __atlsoap_spReadStream;
	__CTempConvert4Service_HelloWorld_struct __params;
	memset(&__params, 0x00, sizeof(__params));
	__params.bstrInput = bstrInput;

	__atlsoap_hr = SetClientStruct(&__params, 2);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_OUTOFMEMORY);
		goto __skip_cleanup;
	}
	
	__atlsoap_hr = GenerateResponse(GetWriteStream());
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_GENERATE_ERROR);
		goto __skip_cleanup;
	}
	
	__atlsoap_hr = SendRequest(_T("SOAPAction: \"#HelloWorld\"\r\n"));
	if (FAILED(__atlsoap_hr))
	{
		goto __skip_cleanup;
	}
	__atlsoap_hr = GetReadStream(&__atlsoap_spReadStream);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_READ_ERROR);
		goto __skip_cleanup;
	}
	
	// cleanup any in/out-params and out-headers from previous calls
	Cleanup();
	__atlsoap_hr = BeginParse(__atlsoap_spReadStream);
	if (FAILED(__atlsoap_hr))
	{
		SetClientError(SOAPCLIENT_PARSE_ERROR);
		goto __cleanup;
	}

	*__retval = __params.__retval;
	goto __skip_cleanup;
	
__cleanup:
	Cleanup();
__skip_cleanup:
	ResetClientState(true);
	memset(&__params, 0x00, sizeof(__params));
	return __atlsoap_hr;
}

template <typename TClient>
ATL_NOINLINE inline const _soapmap ** CTempConvert4ServiceT<TClient>::GetFunctionMap()
{
	return __CTempConvert4Service_funcs;
}

template <typename TClient>
ATL_NOINLINE inline const _soapmap ** CTempConvert4ServiceT<TClient>::GetHeaderMap()
{
	static const _soapmapentry __CTempConvert4Service_ConvertC2F_atlsoapheader_entries[] =
	{
		{ 0x00000000 }
	};

	static const _soapmap __CTempConvert4Service_ConvertC2F_atlsoapheader_map = 
	{
		0x8443255C,
		"ConvertC2F",
		L"ConvertC2F",
		sizeof("ConvertC2F")-1,
		sizeof("ConvertC2F")-1,
		SOAPMAP_HEADER,
		__CTempConvert4Service_ConvertC2F_atlsoapheader_entries,
		0,
		0,
		-1,
		SOAPFLAG_NONE | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
		0xAABE508B,
		"urn:TempConvert4Service",
		L"urn:TempConvert4Service",
		sizeof("urn:TempConvert4Service")-1
	};

	static const _soapmapentry __CTempConvert4Service_ConvertF2C_atlsoapheader_entries[] =
	{
		{ 0x00000000 }
	};

	static const _soapmap __CTempConvert4Service_ConvertF2C_atlsoapheader_map = 
	{
		0x8443321C,
		"ConvertF2C",
		L"ConvertF2C",
		sizeof("ConvertF2C")-1,
		sizeof("ConvertF2C")-1,
		SOAPMAP_HEADER,
		__CTempConvert4Service_ConvertF2C_atlsoapheader_entries,
		0,
		0,
		-1,
		SOAPFLAG_NONE | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
		0xAABE508B,
		"urn:TempConvert4Service",
		L"urn:TempConvert4Service",
		sizeof("urn:TempConvert4Service")-1
	};

	static const _soapmapentry __CTempConvert4Service_HelloWorld_atlsoapheader_entries[] =
	{
		{ 0x00000000 }
	};

	static const _soapmap __CTempConvert4Service_HelloWorld_atlsoapheader_map = 
	{
		0x46BA99FC,
		"HelloWorld",
		L"HelloWorld",
		sizeof("HelloWorld")-1,
		sizeof("HelloWorld")-1,
		SOAPMAP_HEADER,
		__CTempConvert4Service_HelloWorld_atlsoapheader_entries,
		0,
		0,
		-1,
		SOAPFLAG_NONE | SOAPFLAG_RPC | SOAPFLAG_ENCODED,
		0xAABE508B,
		"urn:TempConvert4Service",
		L"urn:TempConvert4Service",
		sizeof("urn:TempConvert4Service")-1
	};


	static const _soapmap * __CTempConvert4Service_headers[] =
	{
		&__CTempConvert4Service_ConvertC2F_atlsoapheader_map,
		&__CTempConvert4Service_ConvertF2C_atlsoapheader_map,
		&__CTempConvert4Service_HelloWorld_atlsoapheader_map,
		NULL
	};
	
	return __CTempConvert4Service_headers;
}

template <typename TClient>
ATL_NOINLINE inline void * CTempConvert4ServiceT<TClient>::GetHeaderValue()
{
	return this;
}

template <typename TClient>
ATL_NOINLINE inline const wchar_t * CTempConvert4ServiceT<TClient>::GetNamespaceUri()
{
	return L"urn:TempConvert4Service";
}

template <typename TClient>
ATL_NOINLINE inline const char * CTempConvert4ServiceT<TClient>::GetServiceName()
{
	return NULL;
}

template <typename TClient>
ATL_NOINLINE inline const char * CTempConvert4ServiceT<TClient>::GetNamespaceUriA()
{
	return "urn:TempConvert4Service";
}

template <typename TClient>
ATL_NOINLINE inline HRESULT CTempConvert4ServiceT<TClient>::CallFunction(
	void *, 
	const wchar_t *, int,
	size_t)
{
	return E_NOTIMPL;
}

template <typename TClient>
ATL_NOINLINE inline HRESULT CTempConvert4ServiceT<TClient>::GetClientReader(ISAXXMLReader **ppReader)
{
	if (ppReader == NULL)
	{
		return E_INVALIDARG;
	}
	
	CComPtr<ISAXXMLReader> spReader = GetReader();
	if (spReader.p != NULL)
	{
		*ppReader = spReader.Detach();
		return S_OK;
	}
	return TClient::GetClientReader(ppReader);
}

} // namespace TempConvert4Service
💿 文件大小 125 K
👤 上传用户 goocool
📂 所属分类嵌入式/单片机编程
🏷️ 相关标签

#温度 #转换 #程序
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -