myvtm/Module/mod_tokenmgr/TokenKeeper_client_g.h

#ifndef __TOKENKEEPER_CLIENT_G_H
#define __TOKENKEEPER_CLIENT_G_H

#pragma once

// This code is generated by spgen tool!

#include "TokenKeeper_def_g.h"

namespace TokenKeeper {
class TokenService_ClientBase : public CClientSessionBase {
public:
	TokenService_ClientBase(CEntityBase *pEntity) : m_pEntityBase(pEntity), m_bSysManaged(false) {}

protected:
	virtual ~TokenService_ClientBase() {}
public:

	ErrorCodeEnum Connect(CSmartPointer<IAsynWaitSp> &spAsyncWait)
	{
		CSmartPointer<IEntityFunction> pFunc = m_pEntityBase->GetFunction();
		ErrorCodeEnum Error = pFunc->ConnectRemoteEntity(this, "TokenKeeper", "TokenService", spAsyncWait);
		if (Error == Error_Succeed) {
			m_bSysManaged = true;
		}
		return Error;
	}
	ErrorCodeEnum Connect()
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = Connect(spAsyncWait);
		if (Error == Error_Succeed) {
			Error = spAsyncWait->WaitAnswer();
		}
		return Error;
	}

	ErrorCodeEnum GetToken(TokenService_GetToken_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_GetToken, TokenService_MethodSignature_GetToken, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum GetToken(TokenService_GetToken_Req &Req, TokenService_GetToken_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = GetToken(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum GetToken(TokenService_GetToken_Req &Req, TokenService_GetToken_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = GetToken(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum SetToken(TokenService_SetToken_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_SetToken, TokenService_MethodSignature_SetToken, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum SetToken(TokenService_SetToken_Req &Req, TokenService_SetToken_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = SetToken(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum SetToken(TokenService_SetToken_Req &Req, TokenService_SetToken_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = SetToken(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum GetSharedSK(TokenService_GetSharedSK_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_GetSharedSK, TokenService_MethodSignature_GetSharedSK, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum GetSharedSK(TokenService_GetSharedSK_Req &Req, TokenService_GetSharedSK_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = GetSharedSK(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum GetSharedSK(TokenService_GetSharedSK_Req &Req, TokenService_GetSharedSK_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = GetSharedSK(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum SetSharedSK(TokenService_SetSharedSK_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_SetSharedSK, TokenService_MethodSignature_SetSharedSK, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum SetSharedSK(TokenService_SetSharedSK_Req &Req, TokenService_SetSharedSK_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = SetSharedSK(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum SetSharedSK(TokenService_SetSharedSK_Req &Req, TokenService_SetSharedSK_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = SetSharedSK(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum SetKeyPair(TokenService_SetKeyPair_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_SetKeyPair, TokenService_MethodSignature_SetKeyPair, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum SetKeyPair(TokenService_SetKeyPair_Req &Req, TokenService_SetKeyPair_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = SetKeyPair(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum SetKeyPair(TokenService_SetKeyPair_Req &Req, TokenService_SetKeyPair_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = SetKeyPair(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum GetPublicKey(TokenService_GetPublicKey_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_GetPublicKey, TokenService_MethodSignature_GetPublicKey, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum GetPublicKey(TokenService_GetPublicKey_Req &Req, TokenService_GetPublicKey_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = GetPublicKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum GetPublicKey(TokenService_GetPublicKey_Req &Req, TokenService_GetPublicKey_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = GetPublicKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum EncryptWithPubKey(TokenService_EncryptWithPubKey_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_EncryptWithPubKey, TokenService_MethodSignature_EncryptWithPubKey, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum EncryptWithPubKey(TokenService_EncryptWithPubKey_Req &Req, TokenService_EncryptWithPubKey_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = EncryptWithPubKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum EncryptWithPubKey(TokenService_EncryptWithPubKey_Req &Req, TokenService_EncryptWithPubKey_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = EncryptWithPubKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum DecryptWithPubKey(TokenService_DecryptWithPubKey_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_DecryptWithPubKey, TokenService_MethodSignature_DecryptWithPubKey, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum DecryptWithPubKey(TokenService_DecryptWithPubKey_Req &Req, TokenService_DecryptWithPubKey_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = DecryptWithPubKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum DecryptWithPubKey(TokenService_DecryptWithPubKey_Req &Req, TokenService_DecryptWithPubKey_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = DecryptWithPubKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum EncryptWithPriKey(TokenService_EncryptWithPriKey_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_EncryptWithPriKey, TokenService_MethodSignature_EncryptWithPriKey, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum EncryptWithPriKey(TokenService_EncryptWithPriKey_Req &Req, TokenService_EncryptWithPriKey_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = EncryptWithPriKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum EncryptWithPriKey(TokenService_EncryptWithPriKey_Req &Req, TokenService_EncryptWithPriKey_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = EncryptWithPriKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}

	ErrorCodeEnum DecryptWithPriKey(TokenService_DecryptWithPriKey_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
	{
		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
		CAutoBuffer Buf = SpObject2Buffer(Req);
		return pFunc->AsyncRequest(TokenService_Method_DecryptWithPriKey, TokenService_MethodSignature_DecryptWithPriKey, Buf, spAsyncWait, dwTimeout);
	}
	ErrorCodeEnum DecryptWithPriKey(TokenService_DecryptWithPriKey_Req &Req, TokenService_DecryptWithPriKey_Ans &Ans, DWORD dwTimeout)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = DecryptWithPriKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}
	ErrorCodeEnum DecryptWithPriKey(TokenService_DecryptWithPriKey_Req &Req, TokenService_DecryptWithPriKey_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
	{
		CSmartPointer<IAsynWaitSp> spAsyncWait;
		ErrorCodeEnum Error = DecryptWithPriKey(Req, spAsyncWait, dwTimeout);
		if (Error == Error_Succeed) {
			bool bEnd = false;
			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, dwTimeout);
			LOG_ASSERT(Error || bEnd);
		}
		return Error;
	}


	bool SafeDelete()
	{
		if (!m_bSysManaged) {
			delete this;
		}
		return m_bSysManaged;
	}

protected:
	bool m_bSysManaged;
	CEntityBase *m_pEntityBase;
};

///////////////////////////

} // namespace TokenKeeper
#endif // __TOKENKEEPER_CLIENT_G_H