myvtm/Module/mod_cardissuer/CardIssuer_server_g.h

#ifndef __CARDISSUER_SERVER_G_H
#define __CARDISSUER_SERVER_G_H

#pragma once

// This code is generated by spgen tool!

#include "CardIssuer_def_g.h"

namespace CardIssuer {
class CardIssuerService_ServerSessionBase : public CServerSessionBase
{
public:
	CardIssuerService_ServerSessionBase() { }

	virtual ~CardIssuerService_ServerSessionBase() { }

	virtual bool IsExclusive() { return false; }

	virtual bool IsSessionOverlap() { return true; }

	virtual ErrorCodeEnum GetMessageAttr(DWORD dwMessageID, DWORD dwSignature, bool &bOverlap)
	{
		ErrorCodeEnum Error = Error_Succeed;
		switch (dwMessageID) {
		case CardIssuerService_Method_Insert:
			if (dwSignature == CardIssuerService_MethodSignature_Insert) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_CancelInsert:
			if (dwSignature == CardIssuerService_MethodSignature_CancelInsert) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_InsertWaitMore:
			if (dwSignature == CardIssuerService_MethodSignature_InsertWaitMore) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Read:
			if (dwSignature == CardIssuerService_MethodSignature_Read) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Capture:
			if (dwSignature == CardIssuerService_MethodSignature_Capture) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Eject:
			if (dwSignature == CardIssuerService_MethodSignature_Eject) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_PreOnline:
			if (dwSignature == CardIssuerService_MethodSignature_PreOnline) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_PostOnline:
			if (dwSignature == CardIssuerService_MethodSignature_PostOnline) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Exit:
			if (dwSignature == CardIssuerService_MethodSignature_Exit) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Issue:
			if (dwSignature == CardIssuerService_MethodSignature_Issue) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetMaterialCount:
			if (dwSignature == CardIssuerService_MethodSignature_GetMaterialCount) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SetMaterialCount:
			if (dwSignature == CardIssuerService_MethodSignature_SetMaterialCount) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SetIssueFlag:
			if (dwSignature == CardIssuerService_MethodSignature_SetIssueFlag) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_ReadEx:
			if (dwSignature == CardIssuerService_MethodSignature_ReadEx) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_QueryCardInfo:
			if (dwSignature == CardIssuerService_MethodSignature_QueryCardInfo) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_WriteTrack:
			if (dwSignature == CardIssuerService_MethodSignature_WriteTrack) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetMaterialCountEx:
			if (dwSignature == CardIssuerService_MethodSignature_GetMaterialCountEx) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SetMaterialCountEx:
			if (dwSignature == CardIssuerService_MethodSignature_SetMaterialCountEx) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SetSomeFlag:
			if (dwSignature == CardIssuerService_MethodSignature_SetSomeFlag) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetSCIInfo:
			if (dwSignature == CardIssuerService_MethodSignature_GetSCIInfo) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_IssueEx:
			if (dwSignature == CardIssuerService_MethodSignature_IssueEx) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_OpenSafeLock:
			if (dwSignature == CardIssuerService_MethodSignature_OpenSafeLock) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SAMICCommand:
			if (dwSignature == CardIssuerService_MethodSignature_SAMICCommand) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_QueryPrinterStatus:
			if (dwSignature == CardIssuerService_MethodSignature_QueryPrinterStatus) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Print:
			if (dwSignature == CardIssuerService_MethodSignature_Print) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_QuerySCIList:
			if (dwSignature == CardIssuerService_MethodSignature_QuerySCIList) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_BindSCI:
			if (dwSignature == CardIssuerService_MethodSignature_BindSCI) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_PreOnlineOnStore:
			if (dwSignature == CardIssuerService_MethodSignature_PreOnlineOnStore) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_NotifyPreonline:
			if (dwSignature == CardIssuerService_MethodSignature_NotifyPreonline) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_QueryCardInfoOnStore:
			if (dwSignature == CardIssuerService_MethodSignature_QueryCardInfoOnStore) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetAddCardInfo:
			if (dwSignature == CardIssuerService_MethodSignature_GetAddCardInfo) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetDevInfo:
			if (dwSignature == CardIssuerService_MethodSignature_GetDevInfo) {
				bOverlap = true;
			} else {
				Error = Error_MethodSignatureFailed;
			}
			break;
		default:
			Error = Error_MethodNotFound;
			break;
		}
		return Error;
	}

	int CheckMessageSignature(DWORD dwMessageID, DWORD dwSignature)
	{
		ErrorCodeEnum Error = Error_Succeed;
		switch (dwMessageID) {
		case CardIssuerService_Method_Insert:
			if (dwSignature != CardIssuerService_MethodSignature_Insert) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_CancelInsert:
			if (dwSignature != CardIssuerService_MethodSignature_CancelInsert) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_InsertWaitMore:
			if (dwSignature != CardIssuerService_MethodSignature_InsertWaitMore) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Read:
			if (dwSignature != CardIssuerService_MethodSignature_Read) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Capture:
			if (dwSignature != CardIssuerService_MethodSignature_Capture) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Eject:
			if (dwSignature != CardIssuerService_MethodSignature_Eject) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_PreOnline:
			if (dwSignature != CardIssuerService_MethodSignature_PreOnline) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_PostOnline:
			if (dwSignature != CardIssuerService_MethodSignature_PostOnline) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Exit:
			if (dwSignature != CardIssuerService_MethodSignature_Exit) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Issue:
			if (dwSignature != CardIssuerService_MethodSignature_Issue) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetMaterialCount:
			if (dwSignature != CardIssuerService_MethodSignature_GetMaterialCount) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SetMaterialCount:
			if (dwSignature != CardIssuerService_MethodSignature_SetMaterialCount) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SetIssueFlag:
			if (dwSignature != CardIssuerService_MethodSignature_SetIssueFlag) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_ReadEx:
			if (dwSignature != CardIssuerService_MethodSignature_ReadEx) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_QueryCardInfo:
			if (dwSignature != CardIssuerService_MethodSignature_QueryCardInfo) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_WriteTrack:
			if (dwSignature != CardIssuerService_MethodSignature_WriteTrack) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetMaterialCountEx:
			if (dwSignature != CardIssuerService_MethodSignature_GetMaterialCountEx) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SetMaterialCountEx:
			if (dwSignature != CardIssuerService_MethodSignature_SetMaterialCountEx) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SetSomeFlag:
			if (dwSignature != CardIssuerService_MethodSignature_SetSomeFlag) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetSCIInfo:
			if (dwSignature != CardIssuerService_MethodSignature_GetSCIInfo) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_IssueEx:
			if (dwSignature != CardIssuerService_MethodSignature_IssueEx) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_OpenSafeLock:
			if (dwSignature != CardIssuerService_MethodSignature_OpenSafeLock) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_SAMICCommand:
			if (dwSignature != CardIssuerService_MethodSignature_SAMICCommand) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_QueryPrinterStatus:
			if (dwSignature != CardIssuerService_MethodSignature_QueryPrinterStatus) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_Print:
			if (dwSignature != CardIssuerService_MethodSignature_Print) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_QuerySCIList:
			if (dwSignature != CardIssuerService_MethodSignature_QuerySCIList) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_BindSCI:
			if (dwSignature != CardIssuerService_MethodSignature_BindSCI) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_PreOnlineOnStore:
			if (dwSignature != CardIssuerService_MethodSignature_PreOnlineOnStore) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_NotifyPreonline:
			if (dwSignature != CardIssuerService_MethodSignature_NotifyPreonline) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_QueryCardInfoOnStore:
			if (dwSignature != CardIssuerService_MethodSignature_QueryCardInfoOnStore) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetAddCardInfo:
			if (dwSignature != CardIssuerService_MethodSignature_GetAddCardInfo) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		case CardIssuerService_Method_GetDevInfo:
			if (dwSignature != CardIssuerService_MethodSignature_GetDevInfo) {
				Error = Error_MethodSignatureFailed;
			}
			break;
		default:
			Error = Error_MethodNotFound;
			break;
		}
		return Error;
	}

	virtual void Handle_Insert(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_CancelInsert(SpOnewayCallContext<CardIssuerService_CancelInsert_Info>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_InsertWaitMore(SpOnewayCallContext<CardIssuerService_InsertWaitMore_Info>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_Read(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_Capture(SpReqAnsContext<CardIssuerService_Capture_Req, CardIssuerService_Capture_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_Eject(SpReqAnsContext<CardIssuerService_Eject_Req, CardIssuerService_Eject_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_Exit(SpOnewayCallContext<CardIssuerService_Exit_Info>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_Issue(SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_GetMaterialCount(SpReqAnsContext<CardIssuerService_GetMaterialCount_Req, CardIssuerService_GetMaterialCount_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_SetMaterialCount(SpReqAnsContext<CardIssuerService_SetMaterialCount_Req, CardIssuerService_SetMaterialCount_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_SetIssueFlag(SpOnewayCallContext<CardIssuerService_SetIssueFlag_Info>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_ReadEx(SpReqAnsContext<CardIssuerService_ReadEx_Req, CardIssuerService_ReadEx_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_QueryCardInfo(SpReqAnsContext<CardIssuerService_QueryCardInfo_Req, CardIssuerService_QueryCardInfo_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_WriteTrack(SpReqAnsContext<CardIssuerService_WriteTrack_Req, CardIssuerService_WriteTrack_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_GetMaterialCountEx(SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req, CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_SetMaterialCountEx(SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req, CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_SetSomeFlag(SpReqAnsContext<CardIssuerService_SetSomeFlag_Req, CardIssuerService_SetSomeFlag_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_GetSCIInfo(SpReqAnsContext<CardIssuerService_GetSCIInfo_Req, CardIssuerService_GetSCIInfo_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_IssueEx(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_OpenSafeLock(SpReqAnsContext<CardIssuerService_OpenSafeLock_Req, CardIssuerService_OpenSafeLock_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_QueryPrinterStatus(SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req, CardIssuerService_QueryPrinterStatus_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_Print(SpReqAnsContext<CardIssuerService_Print_Req, CardIssuerService_Print_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_QuerySCIList(SpReqAnsContext<CardIssuerService_QuerySCIList_Req, CardIssuerService_QuerySCIList_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_BindSCI(SpReqAnsContext<CardIssuerService_BindSCI_Req, CardIssuerService_BindSCI_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_PreOnlineOnStore(SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req, CardIssuerService_PreOnlineOnStore_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_NotifyPreonline(SpReqAnsContext<CardIssuerService_NotifyPreonline_Req, CardIssuerService_NotifyPreonline_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_QueryCardInfoOnStore(SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_GetAddCardInfo(SpReqAnsContext<CardIssuerService_GetAddCardInfo_Req, CardIssuerService_GetAddCardInfo_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void Handle_GetDevInfo(SpReqAnsContext<CardIssuerService_GetDevInfo_Req, CardIssuerService_GetDevInfo_Ans>::Pointer ctx)
	{
	/// override by user
	}

	virtual void OnRequest(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		CAutoBuffer Buf;
		DWORD dwMessageID;
		DWORD dwMessageSignature;
		ErrorCodeEnum Error = pTransactionContext->GetReceiveBuffer(dwMessageID, dwMessageSignature, Buf);
		if (Error == Error_Succeed) {
#ifdef DEBUG
			assert(CheckMessageSignature(dwMessageID, dwMessageSignature) == Error_Succeed);
#else
			if (CheckMessageSignature(dwMessageID, dwMessageSignature) != Error_Succeed) {
				pTransactionContext->SendAnswer(Error_MethodSignatureFailed);
				return;
			}
#endif
			switch (dwMessageID) {
				case CardIssuerService_Method_Insert:
					{
						SpReqAnsContext<CardIssuerService_Insert_Req,CardIssuerService_Insert_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_Insert_Req,CardIssuerService_Insert_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_Insert(ctx);
					}
					break;
				case CardIssuerService_Method_CancelInsert:
					{
						SpOnewayCallContext<CardIssuerService_CancelInsert_Info>::Pointer ctx;
						ctx.Attach(new SpOnewayCallContext<CardIssuerService_CancelInsert_Info>());
						SpBuffer2Object(Buf, ctx->Info);
						Handle_CancelInsert(ctx);
					}
					break;
				case CardIssuerService_Method_InsertWaitMore:
					{
						SpOnewayCallContext<CardIssuerService_InsertWaitMore_Info>::Pointer ctx;
						ctx.Attach(new SpOnewayCallContext<CardIssuerService_InsertWaitMore_Info>());
						SpBuffer2Object(Buf, ctx->Info);
						Handle_InsertWaitMore(ctx);
					}
					break;
				case CardIssuerService_Method_Read:
					{
						SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_Read(ctx);
					}
					break;
				case CardIssuerService_Method_Capture:
					{
						SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_Capture(ctx);
					}
					break;
				case CardIssuerService_Method_Eject:
					{
						SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_Eject(ctx);
					}
					break;
				case CardIssuerService_Method_PreOnline:
					{
						SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_PreOnline(ctx);
					}
					break;
				case CardIssuerService_Method_PostOnline:
					{
						SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_PostOnline(ctx);
					}
					break;
				case CardIssuerService_Method_Exit:
					{
						SpOnewayCallContext<CardIssuerService_Exit_Info>::Pointer ctx;
						ctx.Attach(new SpOnewayCallContext<CardIssuerService_Exit_Info>());
						SpBuffer2Object(Buf, ctx->Info);
						Handle_Exit(ctx);
					}
					break;
				case CardIssuerService_Method_Issue:
					{
						SpReqAnsContext<CardIssuerService_Issue_Req,CardIssuerService_Issue_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_Issue_Req,CardIssuerService_Issue_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_Issue(ctx);
					}
					break;
				case CardIssuerService_Method_GetMaterialCount:
					{
						SpReqAnsContext<CardIssuerService_GetMaterialCount_Req,CardIssuerService_GetMaterialCount_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_GetMaterialCount_Req,CardIssuerService_GetMaterialCount_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_GetMaterialCount(ctx);
					}
					break;
				case CardIssuerService_Method_SetMaterialCount:
					{
						SpReqAnsContext<CardIssuerService_SetMaterialCount_Req,CardIssuerService_SetMaterialCount_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_SetMaterialCount_Req,CardIssuerService_SetMaterialCount_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_SetMaterialCount(ctx);
					}
					break;
				case CardIssuerService_Method_SetIssueFlag:
					{
						SpOnewayCallContext<CardIssuerService_SetIssueFlag_Info>::Pointer ctx;
						ctx.Attach(new SpOnewayCallContext<CardIssuerService_SetIssueFlag_Info>());
						SpBuffer2Object(Buf, ctx->Info);
						Handle_SetIssueFlag(ctx);
					}
					break;
				case CardIssuerService_Method_ReadEx:
					{
						SpReqAnsContext<CardIssuerService_ReadEx_Req,CardIssuerService_ReadEx_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_ReadEx_Req,CardIssuerService_ReadEx_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_ReadEx(ctx);
					}
					break;
				case CardIssuerService_Method_QueryCardInfo:
					{
						SpReqAnsContext<CardIssuerService_QueryCardInfo_Req,CardIssuerService_QueryCardInfo_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_QueryCardInfo_Req,CardIssuerService_QueryCardInfo_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_QueryCardInfo(ctx);
					}
					break;
				case CardIssuerService_Method_WriteTrack:
					{
						SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_WriteTrack(ctx);
					}
					break;
				case CardIssuerService_Method_GetMaterialCountEx:
					{
						SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req,CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req,CardIssuerService_GetMaterialCountEx_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_GetMaterialCountEx(ctx);
					}
					break;
				case CardIssuerService_Method_SetMaterialCountEx:
					{
						SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req,CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req,CardIssuerService_SetMaterialCountEx_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_SetMaterialCountEx(ctx);
					}
					break;
				case CardIssuerService_Method_SetSomeFlag:
					{
						SpReqAnsContext<CardIssuerService_SetSomeFlag_Req,CardIssuerService_SetSomeFlag_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_SetSomeFlag_Req,CardIssuerService_SetSomeFlag_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_SetSomeFlag(ctx);
					}
					break;
				case CardIssuerService_Method_GetSCIInfo:
					{
						SpReqAnsContext<CardIssuerService_GetSCIInfo_Req,CardIssuerService_GetSCIInfo_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_GetSCIInfo_Req,CardIssuerService_GetSCIInfo_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_GetSCIInfo(ctx);
					}
					break;
				case CardIssuerService_Method_IssueEx:
					{
						SpReqAnsContext<CardIssuerService_IssueEx_Req,CardIssuerService_IssueEx_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_IssueEx_Req,CardIssuerService_IssueEx_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_IssueEx(ctx);
					}
					break;
				case CardIssuerService_Method_OpenSafeLock:
					{
						SpReqAnsContext<CardIssuerService_OpenSafeLock_Req,CardIssuerService_OpenSafeLock_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_OpenSafeLock_Req,CardIssuerService_OpenSafeLock_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_OpenSafeLock(ctx);
					}
					break;
				case CardIssuerService_Method_SAMICCommand:
					{
						SpReqAnsContext<CardIssuerService_SAMICCommand_Req,CardIssuerService_SAMICCommand_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_SAMICCommand_Req,CardIssuerService_SAMICCommand_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_SAMICCommand(ctx);
					}
					break;
				case CardIssuerService_Method_QueryPrinterStatus:
					{
						SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req,CardIssuerService_QueryPrinterStatus_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req,CardIssuerService_QueryPrinterStatus_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_QueryPrinterStatus(ctx);
					}
					break;
				case CardIssuerService_Method_Print:
					{
						SpReqAnsContext<CardIssuerService_Print_Req,CardIssuerService_Print_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_Print_Req,CardIssuerService_Print_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_Print(ctx);
					}
					break;
				case CardIssuerService_Method_QuerySCIList:
					{
						SpReqAnsContext<CardIssuerService_QuerySCIList_Req,CardIssuerService_QuerySCIList_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_QuerySCIList_Req,CardIssuerService_QuerySCIList_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_QuerySCIList(ctx);
					}
					break;
				case CardIssuerService_Method_BindSCI:
					{
						SpReqAnsContext<CardIssuerService_BindSCI_Req,CardIssuerService_BindSCI_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_BindSCI_Req,CardIssuerService_BindSCI_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_BindSCI(ctx);
					}
					break;
				case CardIssuerService_Method_PreOnlineOnStore:
					{
						SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req,CardIssuerService_PreOnlineOnStore_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req,CardIssuerService_PreOnlineOnStore_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_PreOnlineOnStore(ctx);
					}
					break;
				case CardIssuerService_Method_NotifyPreonline:
					{
						SpReqAnsContext<CardIssuerService_NotifyPreonline_Req,CardIssuerService_NotifyPreonline_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_NotifyPreonline_Req,CardIssuerService_NotifyPreonline_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_NotifyPreonline(ctx);
					}
					break;
				case CardIssuerService_Method_QueryCardInfoOnStore:
					{
						SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req,CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req,CardIssuerService_QueryCardInfoOnStore_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_QueryCardInfoOnStore(ctx);
					}
					break;
				case CardIssuerService_Method_GetAddCardInfo:
					{
						SpReqAnsContext<CardIssuerService_GetAddCardInfo_Req,CardIssuerService_GetAddCardInfo_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_GetAddCardInfo_Req,CardIssuerService_GetAddCardInfo_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_GetAddCardInfo(ctx);
					}
					break;
				case CardIssuerService_Method_GetDevInfo:
					{
						SpReqAnsContext<CardIssuerService_GetDevInfo_Req,CardIssuerService_GetDevInfo_Ans>::Pointer ctx;
						ctx.Attach(new SpReqAnsContext<CardIssuerService_GetDevInfo_Req,CardIssuerService_GetDevInfo_Ans>(pTransactionContext));
						SpBuffer2Object(Buf, ctx->Req);
						Handle_GetDevInfo(ctx);
					}
					break;
				default:
					assert(0);
					break;
			}
			
		} else {
			pTransactionContext->SendAnswer(Error);
		}
	}

};


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

} // namespace CardIssuer
#endif // __CARDISSUER_SERVER_G_H