OpenV2G/src/service/v2g_serviceDispatcher.c

/*
 * Copyright (C) 2007-2012 Siemens AG
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/*******************************************************************
 *
 * @author Sebastian.Kaebisch.EXT@siemens.com
 * @version 0.6
 * @contact Joerg.Heuer@siemens.com
 *
 * <p>Code generated by EXISeGen</p>
 *
 ********************************************************************/


#include "v2g_service.h"
#include "v2g_serviceDispatcher.h"
#include "v2g_serviceDataTypes.h"
#include "v2g_serviceDataTypes.c"
#include "v2g_serviceMethods.h"
#include "v2g_serviceDataSerialization.c"
#include "EXITypes.h"
#include "EXIDecoder.h"
#include "EXIEncoder.h"
#include "StringTable.h"
#include <string.h>


static int deserializeMessage(struct EXIService* service);


static int _setUInt32Value(integer_t* iv, uint32_t* uint32) {
	int errn = 0;
	switch(iv->type) {
	/* Unsigned Integer */
	case EXI_UNSIGNED_INTEGER_8:
		*uint32 = iv->val.uint8;
		break;
	case EXI_UNSIGNED_INTEGER_16:
		*uint32 = iv->val.uint16;
		break;
	case EXI_UNSIGNED_INTEGER_32:
		if (iv->val.uint32 <= 2147483647) {
			*uint32 = iv->val.uint32;
		} else {
			errn = -1;
		}
		break;
	case EXI_UNSIGNED_INTEGER_64:
		errn = -1;
		break;
	/* (Signed) Integer */
	case EXI_INTEGER_8:
		*uint32 = iv->val.int8;
		break;
	case EXI_INTEGER_16:
		*uint32 = iv->val.int16;
		break;
	case EXI_INTEGER_32:
		*uint32 = iv->val.int32;
		break;
	case EXI_INTEGER_64:
		errn = -1;
	}
	return errn;
}



static int _setInt16Value(integer_t* iv, int16_t* int16) {
	int errn = 0;
	switch(iv->type) {
	/* Unsigned Integer */
	case EXI_UNSIGNED_INTEGER_8:
		*int16 = iv->val.uint8;
		break;
	case EXI_UNSIGNED_INTEGER_16:
		errn = -1;
		break;
	case EXI_UNSIGNED_INTEGER_32:
			errn = -1;
		break;
	case EXI_UNSIGNED_INTEGER_64:
		errn = -1;
		break;
	/* (Signed) Integer */
	case EXI_INTEGER_8:
		*int16 = iv->val.int8;
		break;
	case EXI_INTEGER_16:
		*int16 = iv->val.int16;
		break;
	case EXI_INTEGER_32:
		errn = -1;;
		break;
	case EXI_INTEGER_64:
		errn = -1;
	}
	return errn;
}

/**
 * Deserialize an element value of the EXI stream and assign it to the
 * service data structure 
 */
static int deserializeElementAttributeCharacter(struct EXIService* service)
{

	switch(service->eqn.namespaceURI) {
		case 0:
			switch(service->eqn.localPart) {
				case 0: /*attr_Algorithm*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						if( service->idPath.id[4] == 0)
						{
							memcpy(service->exiMsg.V2G_Message.Header->Signature->SignedInfo.CanonicalizationMethod.attr_Algorithm.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.CanonicalizationMethod.attr_Algorithm.arraylen.data = service->val.string.len;

						} else if(service->idPath.id[4] == 43)
						{
							memcpy(service->exiMsg.V2G_Message.Header->Signature->SignedInfo.SignatureMethod.attr_Algorithm.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.SignatureMethod.attr_Algorithm.arraylen.data = service->val.string.len;

						} else if(service->idPath.id[5] == 5)
						{
							memcpy(service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].DigestMethod.attr_Algorithm.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].DigestMethod.attr_Algorithm.arraylen.data = service->val.string.len;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 2: /*attr_Id*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						if( service->idPath.id[2] == 42)
						{
							memcpy(service->exiMsg.V2G_Message.Header->Signature->attr_Id.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->attr_Id.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Header->Signature->isused.attr_Id=1;

						} else if(service->idPath.id[2] == 25)
						{
							memcpy(service->exiMsg.V2G_Message.Body.ContractAuthenticationReq->attr_Id.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.ContractAuthenticationReq->attr_Id.arraylen.data = service->val.string.len;

						} else if(service->idPath.id[2] == 60)
						{
							memcpy(service->exiMsg.V2G_Message.Body.MeteringReceiptReq->attr_Id.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->attr_Id.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->isused.attr_Id=1;

						} else if(service->idPath.id[2] == 10)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateUpdateReq->attr_Id.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.CertificateUpdateReq->attr_Id.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Body.CertificateUpdateReq->isused.attr_Id=1;

						} else if(service->idPath.id[2] == 6)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateInstallationReq->attr_Id.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.CertificateInstallationReq->attr_Id.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Body.CertificateInstallationReq->isused.attr_Id=1;

						} else if(service->idPath.id[3] == 52)
						{
							memcpy(service->exiMsg.V2G_Message.Header->Signature->SignedInfo.attr_Id.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.attr_Id.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.isused.attr_Id=1;

						} else if(service->idPath.id[3] == 50)
						{

						} else if(service->idPath.id[3] == 14)
						{
							memcpy(service->exiMsg.V2G_Message.Header->Signature->KeyInfo.attr_Id.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->KeyInfo.attr_Id.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Header->Signature->KeyInfo.isused.attr_Id=1;

						} else if(service->idPath.id[4] == 34)
						{
							memcpy(service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].attr_Id.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].attr_Id.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].isused.attr_Id=1;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 7: /*attr_URI*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].attr_URI.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].attr_URI.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].isused.attr_URI=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 6: /*attr_Type*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].attr_Type.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].attr_Type.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].isused.attr_Type=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;	
			} /* close switch(service->eqn.localPart) */	
		break;
		case 4:
			switch(service->eqn.localPart) {
				case 7: /*DigestValue*/
		if(service->val.type == EXI_DATATYPE_BINARY_BASE64) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].DigestValue.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Header->Signature->SignedInfo.Reference[service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference].DigestValue.arraylen.data = service->val.binary.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 50: /*SignatureValue*/

		if(service->val.type == EXI_DATATYPE_BINARY_BASE64)
							{
								memcpy(service->exiMsg.V2G_Message.Header->Signature->SignatureValue.data, service->val.binary.data,service->val.binary.len);
								service->exiMsg.V2G_Message.Header->Signature->SignatureValue.arraylen.data = service->val.binary.len;


							}
							else
							{
								return -1; /* wrong data type */
							}


							break;



				case 62: /*X509IssuerName*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509IssuerSerial.X509IssuerName.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509IssuerSerial.X509IssuerName.arraylen.data = service->val.string.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 66: /*X509SerialNumber*/
		if(service->val.type == EXI_DATATYPE_INTEGER) 
					{
						service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509IssuerSerial.X509SerialNumber = service->val.integer.val.int64;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 65: /*X509SKI*/
		if(service->val.type == EXI_DATATYPE_BINARY_BASE64) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509SKI.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509SKI.arraylen.data = service->val.binary.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 67: /*X509SubjectName*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509SubjectName.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509SubjectName.arraylen.data = service->val.string.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 59: /*X509Certificate*/
		if(service->val.type == EXI_DATATYPE_BINARY_BASE64) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509Certificate.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509Certificate.arraylen.data = service->val.binary.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 58: /*X509CRL*/
		if(service->val.type == EXI_DATATYPE_BINARY_BASE64) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509CRL.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Header->Signature->KeyInfo.X509Data.X509CRL.arraylen.data = service->val.binary.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;	
			} /* close switch(service->eqn.localPart) */	
		break;
		case 5:
			switch(service->eqn.localPart) {
				case 40: /*EVCCID*/
		if(service->val.type == EXI_DATATYPE_BINARY_HEX) 
					{
						memcpy(service->exiMsg.V2G_Message.Body.SessionSetupReq->EVCCID.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.SessionSetupReq->EVCCID.arraylen.data = service->val.binary.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 103: /*ServiceScope*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						memcpy(service->exiMsg.V2G_Message.Body.ServiceDiscoveryReq->ServiceScope.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.ServiceDiscoveryReq->ServiceScope.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Body.ServiceDiscoveryReq->isused.ServiceScope=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 87: /*ServiceCategory*/
		if(service->val.type == EXI_DATATYPE_ENUMERATION) 
					{
						service->exiMsg.V2G_Message.Body.ServiceDiscoveryReq->ServiceCategory = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ServiceDiscoveryReq->isused.ServiceCategory=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 96: /*ServiceID*/
		if(service->val.type == EXI_DATATYPE_UNSIGNED_INTEGER) 
					{
						if( service->idPath.id[2] == 88)
						{
							service->exiMsg.V2G_Message.Body.ServiceDetailReq->ServiceID = service->val.integer.val.uint16;

						} else if(service->idPath.id[4] == 123)
						{
							service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.SelectedService[service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.arraylen.SelectedService].ServiceID = service->val.integer.val.uint16;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 85: /*SelectedPaymentOption*/
		if(service->val.type == EXI_DATATYPE_ENUMERATION) 
					{
						service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedPaymentOption = service->val.enumeration;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 29: /*ContractID*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						if( service->idPath.id[2] == 65)
						{
							memcpy(service->exiMsg.V2G_Message.Body.PaymentDetailsReq->ContractID.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.PaymentDetailsReq->ContractID.arraylen.data = service->val.string.len;

						} else if(service->idPath.id[2] == 10)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractID.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractID.arraylen.data = service->val.string.len;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 57: /*GenChallenge*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						memcpy(service->exiMsg.V2G_Message.Body.ContractAuthenticationReq->GenChallenge.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.ContractAuthenticationReq->GenChallenge.arraylen.data = service->val.string.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 44: /*EVRequestedEnergyTransferType*/
		if(service->val.type == EXI_DATATYPE_ENUMERATION) 
					{
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->EVRequestedEnergyTransferType = service->val.enumeration;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 78: /*ReadyToChargeState*/
		if(service->val.type == EXI_DATATYPE_BOOLEAN) 
					{
						service->exiMsg.V2G_Message.Body.PowerDeliveryReq->ReadyToChargeState = service->val.boolean;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 104: /*SessionID*/
		if(service->val.type == EXI_DATATYPE_BINARY_HEX) 
					{
						if( service->idPath.id[1] == 4)
						{
							memcpy(service->exiMsg.V2G_Message.Header->SessionID.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Header->SessionID.arraylen.data = service->val.binary.len;

						} else if(service->idPath.id[2] == 60)
						{
							memcpy(service->exiMsg.V2G_Message.Body.MeteringReceiptReq->SessionID.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->SessionID.arraylen.data = service->val.binary.len;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 84: /*SAScheduleTupleID*/
		if(service->val.type == EXI_DATATYPE_INTEGER) 
					{

						_setInt16Value( &(service->val.integer),&(service->val.integer.val.int16));
						if( service->idPath.id[2] == 60)
						{
							service->exiMsg.V2G_Message.Body.MeteringReceiptReq->SAScheduleTupleID = service->val.integer.val.int16;
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->isused.SAScheduleTupleID=1;

						} else if(service->idPath.id[3] == 20)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->ChargingProfile.SAScheduleTupleID = service->val.integer.val.int16;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 38: /*DHParams*/
		if(service->val.type == EXI_DATATYPE_BINARY_BASE64) 
					{
						if( service->idPath.id[2] == 10)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateUpdateReq->DHParams.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.CertificateUpdateReq->DHParams.arraylen.data = service->val.binary.len;

						} else if(service->idPath.id[2] == 6)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateInstallationReq->DHParams.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.CertificateInstallationReq->DHParams.arraylen.data = service->val.binary.len;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 64: /*OEMProvisioningCert*/
		if(service->val.type == EXI_DATATYPE_BINARY_BASE64) 
					{
						memcpy(service->exiMsg.V2G_Message.Body.CertificateInstallationReq->OEMProvisioningCert.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.CertificateInstallationReq->OEMProvisioningCert.arraylen.data = service->val.binary.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 1: /*BulkChargingComplete*/
		if(service->val.type == EXI_DATATYPE_BOOLEAN) 
					{
						if( service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->BulkChargingComplete = service->val.boolean;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->isused.BulkChargingComplete=1;

						} else if(service->idPath.id[3] == 21)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->BulkChargingComplete = service->val.boolean;
						service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->isused.BulkChargingComplete=1;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 19: /*ChargingComplete*/
		if(service->val.type == EXI_DATATYPE_BOOLEAN) 
					{
						if( service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->ChargingComplete = service->val.boolean;

						} else if(service->idPath.id[3] == 21)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->ChargingComplete = service->val.boolean;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;	
			} /* close switch(service->eqn.localPart) */	
		break;
		case 6:
			switch(service->eqn.localPart) {
				case 74: /*FaultCode*/
		if(service->val.type == EXI_DATATYPE_ENUMERATION) 
					{
						service->exiMsg.V2G_Message.Header->Notification.FaultCode = service->val.enumeration;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 75: /*FaultMsg*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						memcpy(service->exiMsg.V2G_Message.Header->Notification.FaultMsg.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Header->Notification.FaultMsg.arraylen.data = service->val.string.len;
						service->exiMsg.V2G_Message.Header->Notification.isused.FaultMsg=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 84: /*Multiplier*/
		if(service->val.type == EXI_DATATYPE_NBIT_UNSIGNED_INTEGER) 
					{


						if( service->idPath.id[3] == 56 && service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->EVTargetVoltage.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[3] == 55 && service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->EVTargetCurrent.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[3] == 55 && service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVTargetCurrent.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[3] == 43)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumVoltageLimit.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[3] == 41)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumCurrentLimit.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[3] == 42)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumPowerLimit.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[3] == 81)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->RemainingTimeToFullSoC.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[3] == 80)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->RemainingTimeToBulkSoC.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[3] == 56 && service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVTargetVoltage.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 31)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EAmount.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 40)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMaxVoltage.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 39)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMaxCurrent.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 44)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMinCurrent.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 41)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumCurrentLimit.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 42)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumPowerLimit.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 43)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumVoltageLimit.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 36)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVEnergyCapacity.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 37)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVEnergyRequest.Multiplier = service->val.integer.val.int8;

						} else if(service->idPath.id[4] == 82)
						{
							service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.MeterReading.Multiplier = service->val.integer.val.int8;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 145: /*Unit*/
		if(service->val.type == EXI_DATATYPE_ENUMERATION) 
					{
						if( service->idPath.id[3] == 56 && service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->EVTargetVoltage.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.PreChargeReq->EVTargetVoltage.isused.Unit=1;

						} else if(service->idPath.id[3] == 55 && service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->EVTargetCurrent.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.PreChargeReq->EVTargetCurrent.isused.Unit=1;

						} else if(service->idPath.id[3] == 55 && service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVTargetCurrent.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVTargetCurrent.isused.Unit=1;

						} else if(service->idPath.id[3] == 43)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumVoltageLimit.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumVoltageLimit.isused.Unit=1;

						} else if(service->idPath.id[3] == 41)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumCurrentLimit.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumCurrentLimit.isused.Unit=1;

						} else if(service->idPath.id[3] == 42)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumPowerLimit.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumPowerLimit.isused.Unit=1;

						} else if(service->idPath.id[3] == 81)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->RemainingTimeToFullSoC.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->RemainingTimeToFullSoC.isused.Unit=1;

						} else if(service->idPath.id[3] == 80)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->RemainingTimeToBulkSoC.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->RemainingTimeToBulkSoC.isused.Unit=1;

						} else if(service->idPath.id[3] == 56 && service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVTargetVoltage.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVTargetVoltage.isused.Unit=1;

						} else if(service->idPath.id[4] == 31)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EAmount.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EAmount.isused.Unit=1;

						} else if(service->idPath.id[4] == 40)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMaxVoltage.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMaxVoltage.isused.Unit=1;

						} else if(service->idPath.id[4] == 39)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMaxCurrent.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMaxCurrent.isused.Unit=1;

						} else if(service->idPath.id[4] == 44)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMinCurrent.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMinCurrent.isused.Unit=1;

						} else if(service->idPath.id[4] == 41)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumCurrentLimit.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumCurrentLimit.isused.Unit=1;

						} else if(service->idPath.id[4] == 42)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumPowerLimit.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumPowerLimit.isused.Unit=1;

						} else if(service->idPath.id[4] == 43)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumVoltageLimit.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumVoltageLimit.isused.Unit=1;

						} else if(service->idPath.id[4] == 36)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVEnergyCapacity.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVEnergyCapacity.isused.Unit=1;

						} else if(service->idPath.id[4] == 37)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVEnergyRequest.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVEnergyRequest.isused.Unit=1;

						} else if(service->idPath.id[4] == 82)
						{
							service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.MeterReading.Unit = service->val.enumeration;
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.MeterReading.isused.Unit=1;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 146: /*Value*/
		if(service->val.type == EXI_DATATYPE_INTEGER) 
					{
						_setInt16Value( &(service->val.integer),&(service->val.integer.val.int16));

						if( service->idPath.id[3] == 56 && service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->EVTargetVoltage.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[3] == 55 && service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->EVTargetCurrent.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[3] == 55 && service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVTargetCurrent.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[3] == 43)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumVoltageLimit.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[3] == 41)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumCurrentLimit.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[3] == 42)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVMaximumPowerLimit.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[3] == 81)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->RemainingTimeToFullSoC.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[3] == 80)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->RemainingTimeToBulkSoC.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[3] == 56 && service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->EVTargetVoltage.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 31)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EAmount.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 40)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMaxVoltage.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 39)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMaxCurrent.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 44)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->EVMinCurrent.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 41)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumCurrentLimit.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 42)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumPowerLimit.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 43)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVMaximumVoltageLimit.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 36)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVEnergyCapacity.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 37)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->EVEnergyRequest.Value = service->val.integer.val.int16;

						} else if(service->idPath.id[4] == 82)
						{
							service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.MeterReading.Value = service->val.integer.val.int16;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 130: /*ServiceID*/
		if(service->val.type == EXI_DATATYPE_UNSIGNED_INTEGER) 
					{

						if( service->idPath.id[2] == 88)
						{
							service->exiMsg.V2G_Message.Body.ServiceDetailReq->ServiceID = service->val.integer.val.uint16;

						} else if(service->idPath.id[4] == 123)
						{
							service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.SelectedService[service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.arraylen.SelectedService].ServiceID = service->val.integer.val.uint16;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 96: /*ParameterSetID*/
		if(service->val.type == EXI_DATATYPE_INTEGER) 
					{
						service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.SelectedService[service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.arraylen.SelectedService].ParameterSetID = service->val.integer.val.int16;
						service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.SelectedService[service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.arraylen.SelectedService].isused.ParameterSetID=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 8: /*Certificate*/
		if(service->val.type == EXI_DATATYPE_BINARY_BASE64) 
					{
						if( service->idPath.id[3] == 30)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractSignatureCertChain.Certificate.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractSignatureCertChain.Certificate.arraylen.data = service->val.binary.len;

						} else if(service->idPath.id[2] == 65)
						{
							memcpy(service->exiMsg.V2G_Message.Body.PaymentDetailsReq->ContractSignatureCertChain.SubCertificates.Certificate[service->exiMsg.V2G_Message.Body.PaymentDetailsReq->ContractSignatureCertChain.SubCertificates.arraylen.Certificate].data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.PaymentDetailsReq->ContractSignatureCertChain.SubCertificates.Certificate[service->exiMsg.V2G_Message.Body.PaymentDetailsReq->ContractSignatureCertChain.SubCertificates.arraylen.Certificate].arraylen.data = service->val.binary.len;

						} else if(service->idPath.id[2] == 10)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractSignatureCertChain.SubCertificates.Certificate[service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractSignatureCertChain.SubCertificates.arraylen.Certificate].data, service->val.binary.data,service->val.binary.len);
							service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractSignatureCertChain.SubCertificates.Certificate[service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractSignatureCertChain.SubCertificates.arraylen.Certificate].arraylen.data = service->val.binary.len;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 30: /*DepartureTime*/
		if(service->val.type == EXI_DATATYPE_UNSIGNED_INTEGER) 
					{
						_setUInt32Value( &(service->val.integer),&(service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->AC_EVChargeParameter->DepartureTime));


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 49: /*EVReady*/
		if(service->val.type == EXI_DATATYPE_BOOLEAN) 
					{
						if( service->idPath.id[2] == 2)
						{
							service->exiMsg.V2G_Message.Body.CableCheckReq->DC_EVStatus.EVReady = service->val.boolean;

						} else if(service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->DC_EVStatus.EVReady = service->val.boolean;

						} else if(service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->DC_EVStatus.EVReady = service->val.boolean;

						} else if(service->idPath.id[2] == 113)
						{
							service->exiMsg.V2G_Message.Body.WeldingDetectionReq->DC_EVStatus.EVReady = service->val.boolean;

						} else if(service->idPath.id[2] == 14)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->DC_EVStatus.EVReady = service->val.boolean;

						} else if(service->idPath.id[2] == 70)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->DC_EVStatus.EVReady = service->val.boolean;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 33: /*EVCabinConditioning*/
		if(service->val.type == EXI_DATATYPE_BOOLEAN) 
					{
						if( service->idPath.id[2] == 2)
						{
							service->exiMsg.V2G_Message.Body.CableCheckReq->DC_EVStatus.EVCabinConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.CableCheckReq->DC_EVStatus.isused.EVCabinConditioning=1;

						} else if(service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->DC_EVStatus.EVCabinConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.PreChargeReq->DC_EVStatus.isused.EVCabinConditioning=1;

						} else if(service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->DC_EVStatus.EVCabinConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->DC_EVStatus.isused.EVCabinConditioning=1;

						} else if(service->idPath.id[2] == 113)
						{
							service->exiMsg.V2G_Message.Body.WeldingDetectionReq->DC_EVStatus.EVCabinConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.WeldingDetectionReq->DC_EVStatus.isused.EVCabinConditioning=1;

						} else if(service->idPath.id[2] == 14)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->DC_EVStatus.EVCabinConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->DC_EVStatus.isused.EVCabinConditioning=1;

						} else if(service->idPath.id[2] == 70)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->DC_EVStatus.EVCabinConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->DC_EVStatus.isused.EVCabinConditioning=1;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 47: /*EVRESSConditioning*/
		if(service->val.type == EXI_DATATYPE_BOOLEAN) 
					{
						if( service->idPath.id[2] == 2)
						{
							service->exiMsg.V2G_Message.Body.CableCheckReq->DC_EVStatus.EVRESSConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.CableCheckReq->DC_EVStatus.isused.EVRESSConditioning=1;

						} else if(service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->DC_EVStatus.EVRESSConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.PreChargeReq->DC_EVStatus.isused.EVRESSConditioning=1;

						} else if(service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->DC_EVStatus.EVRESSConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->DC_EVStatus.isused.EVRESSConditioning=1;

						} else if(service->idPath.id[2] == 113)
						{
							service->exiMsg.V2G_Message.Body.WeldingDetectionReq->DC_EVStatus.EVRESSConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.WeldingDetectionReq->DC_EVStatus.isused.EVRESSConditioning=1;

						} else if(service->idPath.id[2] == 14)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->DC_EVStatus.EVRESSConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->DC_EVStatus.isused.EVRESSConditioning=1;

						} else if(service->idPath.id[2] == 70)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->DC_EVStatus.EVRESSConditioning = service->val.boolean;
						service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->DC_EVStatus.isused.EVRESSConditioning=1;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 38: /*EVErrorCode*/
		if(service->val.type == EXI_DATATYPE_ENUMERATION) 
					{
						if( service->idPath.id[2] == 2)
						{
							service->exiMsg.V2G_Message.Body.CableCheckReq->DC_EVStatus.EVErrorCode = service->val.enumeration;

						} else if(service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->DC_EVStatus.EVErrorCode = service->val.enumeration;

						} else if(service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->DC_EVStatus.EVErrorCode = service->val.enumeration;

						} else if(service->idPath.id[2] == 113)
						{
							service->exiMsg.V2G_Message.Body.WeldingDetectionReq->DC_EVStatus.EVErrorCode = service->val.enumeration;

						} else if(service->idPath.id[2] == 14)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->DC_EVStatus.EVErrorCode = service->val.enumeration;

						} else if(service->idPath.id[2] == 70)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->DC_EVStatus.EVErrorCode = service->val.enumeration;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 48: /*EVRESSSOC*/
		if(service->val.type == EXI_DATATYPE_NBIT_UNSIGNED_INTEGER) 
					{
						if( service->idPath.id[2] == 2)
						{
							service->exiMsg.V2G_Message.Body.CableCheckReq->DC_EVStatus.EVRESSSOC = service->val.integer.val.int8;

						} else if(service->idPath.id[2] == 74)
						{
							service->exiMsg.V2G_Message.Body.PreChargeReq->DC_EVStatus.EVRESSSOC = service->val.integer.val.int8;

						} else if(service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->DC_EVStatus.EVRESSSOC = service->val.integer.val.int8;

						} else if(service->idPath.id[2] == 113)
						{
							service->exiMsg.V2G_Message.Body.WeldingDetectionReq->DC_EVStatus.EVRESSSOC = service->val.integer.val.int8;

						} else if(service->idPath.id[2] == 14)
						{
							service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->DC_EVStatus.EVRESSSOC = service->val.integer.val.int8;

						} else if(service->idPath.id[2] == 70)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->DC_EVStatus.EVRESSSOC = service->val.integer.val.int8;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 77: /*FullSOC*/
		if(service->val.type == EXI_DATATYPE_NBIT_UNSIGNED_INTEGER) 
					{
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->FullSOC = service->val.integer.val.int8;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->isused.FullSOC=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 7: /*BulkSOC*/
		if(service->val.type == EXI_DATATYPE_NBIT_UNSIGNED_INTEGER) 
					{
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->BulkSOC = service->val.integer.val.int8;
						service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->isused.BulkSOC=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 12: /*ChargingProfileEntryStart*/
		if(service->val.type == EXI_DATATYPE_UNSIGNED_INTEGER) 
					{
						_setUInt32Value( &(service->val.integer),&(service->exiMsg.V2G_Message.Body.PowerDeliveryReq->ChargingProfile.ProfileEntry[service->exiMsg.V2G_Message.Body.PowerDeliveryReq->ChargingProfile.arraylen.ProfileEntry].ChargingProfileEntryStart));


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 11: /*ChargingProfileEntryMaxPower*/
		if(service->val.type == EXI_DATATYPE_INTEGER) 
					{

			_setInt16Value( &(service->val.integer),&(service->val.integer.val.int16));
						service->exiMsg.V2G_Message.Body.PowerDeliveryReq->ChargingProfile.ProfileEntry[service->exiMsg.V2G_Message.Body.PowerDeliveryReq->ChargingProfile.arraylen.ProfileEntry].ChargingProfileEntryMaxPower = service->val.integer.val.int16;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 113: /*SAScheduleTupleID*/
		if(service->val.type == EXI_DATATYPE_INTEGER) 
					{
						_setInt16Value( &(service->val.integer),&(service->val.integer.val.int16));
						if( service->idPath.id[2] == 60)
						{
							service->exiMsg.V2G_Message.Body.MeteringReceiptReq->SAScheduleTupleID = service->val.integer.val.int16;
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->isused.SAScheduleTupleID=1;

						} else if(service->idPath.id[3] == 20)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->ChargingProfile.SAScheduleTupleID = service->val.integer.val.int16;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 6: /*BulkChargingComplete*/
		if(service->val.type == EXI_DATATYPE_BOOLEAN) 
					{
						if( service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->BulkChargingComplete = service->val.boolean;
						service->exiMsg.V2G_Message.Body.CurrentDemandReq->isused.BulkChargingComplete=1;

						} else if(service->idPath.id[3] == 21)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->BulkChargingComplete = service->val.boolean;
						service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->isused.BulkChargingComplete=1;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 10: /*ChargingComplete*/
		if(service->val.type == EXI_DATATYPE_BOOLEAN) 
					{
						if( service->idPath.id[2] == 32)
						{
							service->exiMsg.V2G_Message.Body.CurrentDemandReq->ChargingComplete = service->val.boolean;

						} else if(service->idPath.id[3] == 21)
						{
							service->exiMsg.V2G_Message.Body.PowerDeliveryReq->DC_EVPowerDeliveryParameter->ChargingComplete = service->val.boolean;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 80: /*MeterID*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						memcpy(service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.MeterID.data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.MeterID.arraylen.data = service->val.string.len;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 139: /*SigMeterReading*/
		if(service->val.type == EXI_DATATYPE_BINARY_BASE64) 
					{
						memcpy(service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.SigMeterReading.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.SigMeterReading.arraylen.data = service->val.binary.len;
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.isused.SigMeterReading=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 83: /*MeterStatus*/
		if(service->val.type == EXI_DATATYPE_INTEGER) 
					{
						_setInt16Value( &(service->val.integer),&(service->val.integer.val.int16));
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.MeterStatus = service->val.integer.val.int16;
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.isused.MeterStatus=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 143: /*TMeter*/
		if(service->val.type == EXI_DATATYPE_INTEGER) 
					{
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.TMeter = service->val.integer.val.int64;
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.isused.TMeter=1;


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;
				case 108: /*RootCertificateID*/
		if(service->val.type == EXI_DATATYPE_STRING) 
					{
						if( service->idPath.id[2] == 10)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ListOfRootCertificateIDs.RootCertificateID[service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ListOfRootCertificateIDs.arraylen.RootCertificateID].data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
						service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ListOfRootCertificateIDs.RootCertificateID[service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ListOfRootCertificateIDs.arraylen.RootCertificateID].arraylen.data = service->val.string.len;

						} else if(service->idPath.id[2] == 6)
						{
							memcpy(service->exiMsg.V2G_Message.Body.CertificateInstallationReq->ListOfRootCertificateIDs.RootCertificateID[service->exiMsg.V2G_Message.Body.CertificateInstallationReq->ListOfRootCertificateIDs.arraylen.RootCertificateID].data, service->val.string.codepoints,service->val.string.len*sizeof(uint32_t));
																	service->exiMsg.V2G_Message.Body.CertificateInstallationReq->ListOfRootCertificateIDs.RootCertificateID[service->exiMsg.V2G_Message.Body.CertificateInstallationReq->ListOfRootCertificateIDs.arraylen.RootCertificateID].arraylen.data = service->val.string.len;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;	
			} /* close switch(service->eqn.localPart) */	
		break;
		case 8:
			switch(service->eqn.localPart) {
				case 2: /*SessionID*/
		if(service->val.type == EXI_DATATYPE_BINARY_HEX) 
					{
						if( service->idPath.id[1] == 4)
						{
							memcpy(service->exiMsg.V2G_Message.Header->SessionID.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Header->SessionID.arraylen.data = service->val.binary.len;

						} else if(service->idPath.id[2] == 60)
						{
							memcpy(service->exiMsg.V2G_Message.Body.MeteringReceiptReq->SessionID.data, service->val.binary.data,service->val.binary.len);
						service->exiMsg.V2G_Message.Body.MeteringReceiptReq->SessionID.arraylen.data = service->val.binary.len;
						}


					} 
					else
					{
						return -1; /* wrong data type */
					}

				break;	
			} /* close switch(service->eqn.localPart) */	
		break;
	
	} /* close switch(service->eqn.namespaceURI) */
	return 0;
}

/**
 * Depending on the current EXI event a message element is deserialized or a
 * defined service method is called in here
 */
static int deserializeElementOrServiceCall(struct EXIService* service)
{

	switch(service->eqn.namespaceURI) {
		case 0:
			switch(service->eqn.localPart) {
			}
		break;
		case 4:
			switch(service->eqn.localPart) {
				case 34:/* Reference */	
	
 					service->exiMsg.V2G_Message.Header->Signature->SignedInfo.arraylen.Reference++;

				break;
				case 14:/* KeyInfo */	
	
 					service->exiMsg.V2G_Message.Header->Signature->isused.KeyInfo=1;

				break;
				case 42:/* Signature */	
	
 					service->exiMsg.V2G_Message.Header->isused.Signature=1;

				break;
			}
		break;
		case 5:
			switch(service->eqn.localPart) {
				case 20:/* ChargingProfile */	
	
 					service->exiMsg.V2G_Message.Body.PowerDeliveryReq->isused.ChargingProfile=1;

				break;
				case 43:/* EVMaximumVoltageLimit */	
	
 					service->exiMsg.V2G_Message.Body.CurrentDemandReq->isused.EVMaximumVoltageLimit=1;

				break;
				case 41:/* EVMaximumCurrentLimit */	
	
 					service->exiMsg.V2G_Message.Body.CurrentDemandReq->isused.EVMaximumCurrentLimit=1;

				break;
				case 42:/* EVMaximumPowerLimit */	
	
 					service->exiMsg.V2G_Message.Body.CurrentDemandReq->isused.EVMaximumPowerLimit=1;

				break;
				case 81:/* RemainingTimeToFullSoC */	
	
 					service->exiMsg.V2G_Message.Body.CurrentDemandReq->isused.RemainingTimeToFullSoC=1;

				break;
				case 80:/* RemainingTimeToBulkSoC */	
	
 					service->exiMsg.V2G_Message.Body.CurrentDemandReq->isused.RemainingTimeToBulkSoC=1;

				break;
				case 105:/* SessionSetupReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					sessionSetup((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.SessionSetupReq), (service->exiMsg.V2G_Message.Body.SessionSetupRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.SessionSetupRes=1;
					service->exiMsg.V2G_Message.Body.isused.SessionSetupReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 92:/* ServiceDiscoveryReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					serviceDiscovery((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.ServiceDiscoveryReq), (service->exiMsg.V2G_Message.Body.ServiceDiscoveryRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.ServiceDiscoveryRes=1;
					service->exiMsg.V2G_Message.Body.isused.ServiceDiscoveryReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 88:/* ServiceDetailReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					serviceDetail((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.ServiceDetailReq), (service->exiMsg.V2G_Message.Body.ServiceDetailRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.ServiceDetailRes=1;
					service->exiMsg.V2G_Message.Body.isused.ServiceDetailReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 99:/* ServicePaymentSelectionReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					servicePaymentSelection((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq), (service->exiMsg.V2G_Message.Body.ServicePaymentSelectionRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.ServicePaymentSelectionRes=1;
					service->exiMsg.V2G_Message.Body.isused.ServicePaymentSelectionReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 65:/* PaymentDetailsReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					paymentDetails((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.PaymentDetailsReq), (service->exiMsg.V2G_Message.Body.PaymentDetailsRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.PaymentDetailsRes=1;
					service->exiMsg.V2G_Message.Body.isused.PaymentDetailsReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 25:/* ContractAuthenticationReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					contractAuthentication((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.ContractAuthenticationReq), (service->exiMsg.V2G_Message.Body.ContractAuthenticationRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.ContractAuthenticationRes=1;
					service->exiMsg.V2G_Message.Body.isused.ContractAuthenticationReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 14:/* ChargeParameterDiscoveryReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					chargeParameterDiscovery((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq), (service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.ChargeParameterDiscoveryRes=1;
					service->exiMsg.V2G_Message.Body.isused.ChargeParameterDiscoveryReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 70:/* PowerDeliveryReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					powerDelivery((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.PowerDeliveryReq), (service->exiMsg.V2G_Message.Body.PowerDeliveryRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.PowerDeliveryRes=1;
					service->exiMsg.V2G_Message.Body.isused.PowerDeliveryReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 21:/* ChargingStatusReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					chargingStatus((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.ChargingStatusReq), (service->exiMsg.V2G_Message.Body.ChargingStatusRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.ChargingStatusRes=1;
					service->exiMsg.V2G_Message.Body.isused.ChargingStatusReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 60:/* MeteringReceiptReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					meteringReceipt((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.MeteringReceiptReq), (service->exiMsg.V2G_Message.Body.MeteringReceiptRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.MeteringReceiptRes=1;
					service->exiMsg.V2G_Message.Body.isused.MeteringReceiptReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 109:/* SessionStopReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					sessionStop((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.SessionStopReq), (service->exiMsg.V2G_Message.Body.SessionStopRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.SessionStopRes=1;
					service->exiMsg.V2G_Message.Body.isused.SessionStopReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 10:/* CertificateUpdateReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					certificateUpdate((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.CertificateUpdateReq), (service->exiMsg.V2G_Message.Body.CertificateUpdateRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.CertificateUpdateRes=1;
					service->exiMsg.V2G_Message.Body.isused.CertificateUpdateReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 6:/* CertificateInstallationReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					certificateInstallation((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.CertificateInstallationReq), (service->exiMsg.V2G_Message.Body.CertificateInstallationRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.CertificateInstallationRes=1;
					service->exiMsg.V2G_Message.Body.isused.CertificateInstallationReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 2:/* CableCheckReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					cableCheck((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.CableCheckReq), (service->exiMsg.V2G_Message.Body.CableCheckRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.CableCheckRes=1;
					service->exiMsg.V2G_Message.Body.isused.CableCheckReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 74:/* PreChargeReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					preCharge((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.PreChargeReq), (service->exiMsg.V2G_Message.Body.PreChargeRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.PreChargeRes=1;
					service->exiMsg.V2G_Message.Body.isused.PreChargeReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 32:/* CurrentDemandReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					currentDemand((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.CurrentDemandReq), (service->exiMsg.V2G_Message.Body.CurrentDemandRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.CurrentDemandRes=1;
					service->exiMsg.V2G_Message.Body.isused.CurrentDemandReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
				case 113:/* WeldingDetectionReq */	
	
 		
			
							
					/* test, if data length is unequal to the expected payload  */
					/*if((service->inStream.size)!= *(service->inStream.pos))
					{
						service->errorCode = EXI_NON_VALID_MESSAGE;
						return -1;
					}	*/		
			
					/* service call */
					weldingDetection((service->exiMsg.V2G_Message.Header),(service->exiMsg.V2G_Message.Body.WeldingDetectionReq), (service->exiMsg.V2G_Message.Body.WeldingDetectionRes));
							
					/* signalize the response message */
					service->exiMsg.V2G_Message.Body.isused.WeldingDetectionRes=1;
					service->exiMsg.V2G_Message.Body.isused.WeldingDetectionReq=0;
					
					/* serialize the response data */
					if(serialize_message(service))
					{
						/* serializiation error*/
						service->errorCode= EXI_SERIALIZATION_FAILED;
					} 

			
		
				break;
			}
		break;
		case 6:
			switch(service->eqn.localPart) {
				case 123:/* SelectedService */	
	
 					service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq->SelectedServiceList.arraylen.SelectedService++;

				break;
				case 141:/* SubCertificates */	
	
 		if( service->idPath.id[2] == 65)
				{
								service->exiMsg.V2G_Message.Body.PaymentDetailsReq->ContractSignatureCertChain.isused.SubCertificates=1;

				} else if(service->idPath.id[2] == 10)
				{
								service->exiMsg.V2G_Message.Body.CertificateUpdateReq->ContractSignatureCertChain.isused.SubCertificates=1;
				}

				break;
				case 42:/* EVMaximumPowerLimit */	
	
 					service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->isused.EVMaximumPowerLimit=1;

				break;
				case 36:/* EVEnergyCapacity */	
	
 					service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->isused.EVEnergyCapacity=1;

				break;
				case 37:/* EVEnergyRequest */	
	
 					service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->DC_EVChargeParameter->isused.EVEnergyRequest=1;

				break;
				case 0:/* AC_EVChargeParameter */	
	
 					service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->isused.AC_EVChargeParameter=1;

				break;
				case 18:/* DC_EVChargeParameter */	
	
 					service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq->isused.DC_EVChargeParameter=1;

				break;
				case 103:/* ProfileEntry */	
	
 					service->exiMsg.V2G_Message.Body.PowerDeliveryReq->ChargingProfile.arraylen.ProfileEntry++;

				break;
				case 21:/* DC_EVPowerDeliveryParameter */	
	
 					service->exiMsg.V2G_Message.Body.PowerDeliveryReq->isused.DC_EVPowerDeliveryParameter=1;

				break;
				case 82:/* MeterReading */	
	
 					service->exiMsg.V2G_Message.Body.MeteringReceiptReq->MeterInfo.isused.MeterReading=1;

				break;
			}
		break;
		case 8:
			switch(service->eqn.localPart) {
				case 1:/* Notification */	
	
 					service->exiMsg.V2G_Message.Header->isused.Notification=1;

				break;
			}
		break;
		

	}
	return 0;
}

static int deserializeSessionSetupReqMsg(struct EXIService* service)
{
	struct SessionSetupReqType reqMsg;
	struct SessionSetupResType resMsg;
	service->exiMsg.V2G_Message.Body.SessionSetupReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.SessionSetupRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeServiceDiscoveryReqMsg(struct EXIService* service)
{
	struct ServiceDiscoveryReqType reqMsg;
	struct ServiceDiscoveryResType resMsg;
	init_ServiceDiscoveryReqType(&reqMsg);
	
	service->exiMsg.V2G_Message.Body.ServiceDiscoveryReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.ServiceDiscoveryRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeServiceDetailReqMsg(struct EXIService* service)
{
	struct ServiceDetailReqType reqMsg;
	struct ServiceDetailResType resMsg;
	service->exiMsg.V2G_Message.Body.ServiceDetailReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.ServiceDetailRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeServicePaymentSelectionReqMsg(struct EXIService* service)
{
	struct ServicePaymentSelectionReqType reqMsg;
	struct ServicePaymentSelectionResType resMsg;
	init_ServicePaymentSelectionReqType(&reqMsg);
	
	service->exiMsg.V2G_Message.Body.ServicePaymentSelectionReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.ServicePaymentSelectionRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializePaymentDetailsReqMsg(struct EXIService* service)
{
	struct PaymentDetailsReqType reqMsg;
	struct PaymentDetailsResType resMsg;
	init_PaymentDetailsReqType(&reqMsg);
	
	service->exiMsg.V2G_Message.Body.PaymentDetailsReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.PaymentDetailsRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeContractAuthenticationReqMsg(struct EXIService* service)
{
	struct ContractAuthenticationReqType reqMsg;
	struct ContractAuthenticationResType resMsg;
	service->exiMsg.V2G_Message.Body.ContractAuthenticationReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.ContractAuthenticationRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeChargeParameterDiscoveryReqMsg(struct EXIService* service)
{
	struct ChargeParameterDiscoveryReqType reqMsg;
	struct ChargeParameterDiscoveryResType resMsg;
	struct DC_EVChargeParameterType dc_pev;
	struct AC_EVChargeParameterType ac_pev;
	struct DC_EVSEChargeParameterType dc_evse;
	struct AC_EVSEChargeParameterType ac_evse;
	struct SAScheduleListType tuple;
	struct SalesTariffType sales1;
	struct SalesTariffType sales2;

	init_AC_EVChargeParameterType(&ac_pev);

	init_ChargeParameterDiscoveryReqType(&reqMsg);
	init_DC_EVSEChargeParameterType(&dc_evse);
	init_AC_EVSEChargeParameterType(&ac_evse);
	init_DC_EVChargeParameterType(&dc_pev);
	init_SAScheduleListType(&tuple);
	init_SalesTariffType(&sales1);
	init_SalesTariffType(&sales2);

	reqMsg.AC_EVChargeParameter = &ac_pev;
	reqMsg.DC_EVChargeParameter = &dc_pev;
	resMsg.AC_EVSEChargeParameter = &ac_evse;
	resMsg.DC_EVSEChargeParameter= &dc_evse;

	service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.ChargeParameterDiscoveryRes = &resMsg;

	tuple.SAScheduleTuple[0].SalesTariff = &sales1;
	tuple.SAScheduleTuple[1].SalesTariff =  &sales2;
	resMsg.SAScheduleList = &tuple;


	
	return deserializeMessage(service);
}

static int deserializePowerDeliveryReqMsg(struct EXIService* service)
{
	struct PowerDeliveryReqType reqMsg;
	struct PowerDeliveryResType resMsg;
	struct DC_EVPowerDeliveryParameterType EVPowerDelivery;

	struct DC_EVSEStatusType dc_evse;
	struct AC_EVSEStatusType ac_evse;

	init_DC_EVPowerDeliveryParameterType(&EVPowerDelivery);
	init_PowerDeliveryReqType(&reqMsg);


	resMsg.AC_EVSEStatus = &ac_evse;
	resMsg.DC_EVSEStatus = &dc_evse;

	reqMsg.DC_EVPowerDeliveryParameter = &EVPowerDelivery;

	service->exiMsg.V2G_Message.Body.PowerDeliveryReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.PowerDeliveryRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeChargingStatusReqMsg(struct EXIService* service)
{
	struct ChargingStatusReqType reqMsg;
	struct ChargingStatusResType resMsg;
	service->exiMsg.V2G_Message.Body.ChargingStatusReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.ChargingStatusRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeMeteringReceiptReqMsg(struct EXIService* service)
{
	struct MeteringReceiptReqType reqMsg;
	struct MeteringReceiptResType resMsg;
	init_MeteringReceiptReqType(&reqMsg);
	
	service->exiMsg.V2G_Message.Body.MeteringReceiptReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.MeteringReceiptRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeCertificateUpdateReqMsg(struct EXIService* service)
{
	struct CertificateUpdateReqType reqMsg;
	struct CertificateUpdateResType resMsg;
	init_CertificateUpdateReqType(&reqMsg);
	
	service->exiMsg.V2G_Message.Body.CertificateUpdateReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.CertificateUpdateRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeCertificateInstallationReqMsg(struct EXIService* service)
{
	struct CertificateInstallationReqType reqMsg;
	struct CertificateInstallationResType resMsg;
	init_CertificateInstallationReqType(&reqMsg);
	
	service->exiMsg.V2G_Message.Body.CertificateInstallationReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.CertificateInstallationRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeCableCheckReqMsg(struct EXIService* service)
{
	struct CableCheckReqType reqMsg;
	struct CableCheckResType resMsg;
	service->exiMsg.V2G_Message.Body.CableCheckReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.CableCheckRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializePreChargeReqMsg(struct EXIService* service)
{
	struct PreChargeReqType reqMsg;
	struct PreChargeResType resMsg;
	init_PreChargeReqType(&reqMsg);
	
	service->exiMsg.V2G_Message.Body.PreChargeReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.PreChargeRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeCurrentDemandReqMsg(struct EXIService* service)
{
	struct CurrentDemandReqType reqMsg;
	struct CurrentDemandResType resMsg;
	init_CurrentDemandReqType(&reqMsg);
	
	service->exiMsg.V2G_Message.Body.CurrentDemandReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.CurrentDemandRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeWeldingDetectionReqMsg(struct EXIService* service)
{
	struct WeldingDetectionReqType reqMsg;
	struct WeldingDetectionResType resMsg;
	service->exiMsg.V2G_Message.Body.WeldingDetectionReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.WeldingDetectionRes = &resMsg;
	
	return deserializeMessage(service);
}

static int deserializeSessionStopReqMsg(struct EXIService* service)
{
	struct SessionStopType reqMsg;
	struct SessionStopResType resMsg;
	service->exiMsg.V2G_Message.Body.SessionStopReq = &reqMsg;
	service->exiMsg.V2G_Message.Body.SessionStopRes = &resMsg;
	
	return deserializeMessage(service);
}

/** 
 * Deserialize the EXI stream
 * @return 0 = 0K; -1 = ERROR
 */
static int deserializeMessage(struct EXIService* service)
{
	int noEndOfDocument = 1; /* true */
	int returnCode=0;


	do {
			exiDecodeNextEvent(&(service->inStream), &(service->stateDecode), &(service->event));
			if (returnCode) 
			{
				
				if(service->errorCode==0) 
				{
					service->errorCode= EXI_NON_VALID_MESSAGE;
				}
			
				return returnCode;
			}

			switch (service->event) {
			case EXI_EVENT_START_DOCUMENT:

				returnCode = exiDecodeStartDocument(&(service->inStream), &(service->stateDecode));

				break;
			case EXI_EVENT_END_DOCUMENT:

				returnCode = exiDecodeEndDocument(&(service->inStream), &(service->stateDecode));
				noEndOfDocument = 0; /* false */
				break;
			case EXI_EVENT_START_ELEMENT:
				returnCode = exiDecodeStartElement(&(service->inStream), &(service->stateDecode), &(service->eqn));
				service->idPath.id[service->idPath.pos++]=service->eqn.localPart;
				 
				 /* setup the request context*/
				 if(service->eqn.localPart==105 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeSessionSetupReqMsg(service);
				   } else if(service->eqn.localPart==92 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeServiceDiscoveryReqMsg(service);
				   } else if(service->eqn.localPart==88 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeServiceDetailReqMsg(service);
				   } else if(service->eqn.localPart==99 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeServicePaymentSelectionReqMsg(service);
				   } else if(service->eqn.localPart==65 && service->eqn.namespaceURI==5)
				  {
				 	return deserializePaymentDetailsReqMsg(service);
				   } else if(service->eqn.localPart==25 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeContractAuthenticationReqMsg(service);
				   } else if(service->eqn.localPart==14 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeChargeParameterDiscoveryReqMsg(service);
				   } else if(service->eqn.localPart==70 && service->eqn.namespaceURI==5)
				  {
				 	return deserializePowerDeliveryReqMsg(service);
				   } else if(service->eqn.localPart==21 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeChargingStatusReqMsg(service);
				   } else if(service->eqn.localPart==60 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeMeteringReceiptReqMsg(service);
				   } else if(service->eqn.localPart==109 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeSessionStopReqMsg(service);
				   } else if(service->eqn.localPart==10 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeCertificateUpdateReqMsg(service);
				   } else if(service->eqn.localPart==6 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeCertificateInstallationReqMsg(service);
				   } else if(service->eqn.localPart==2 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeCableCheckReqMsg(service);
				   } else if(service->eqn.localPart==74 && service->eqn.namespaceURI==5)
				  {
				 	return deserializePreChargeReqMsg(service);
				   } else if(service->eqn.localPart==32 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeCurrentDemandReqMsg(service);
				   } else if(service->eqn.localPart==113 && service->eqn.namespaceURI==5)
				  {
				 	return deserializeWeldingDetectionReqMsg(service);
				   } 				 
				 
				 
				break;
			case EXI_EVENT_END_ELEMENT:

				returnCode = exiDecodeEndElement(&(service->inStream), &(service->stateDecode), &(service->eqn));
				returnCode = deserializeElementOrServiceCall(service);
				service->idPath.pos--;
				 
				break;
			case EXI_EVENT_CHARACTERS:
				/* decode */
				returnCode = exiDecodeCharacters(&(service->inStream), &(service->stateDecode), &(service->val));
				 
				/* assign data to the EXI message structure */
				returnCode = deserializeElementAttributeCharacter(service);
				break;
			case EXI_EVENT_ATTRIBUTE:
				/* decode */
				returnCode = exiDecodeAttribute(&(service->inStream), &(service->stateDecode), &(service->eqn), &(service->val));
				returnCode = deserializeElementAttributeCharacter(service);
				break;
			case EXI_EVENT_START_ELEMENT_GENERIC:
				break;
			case EXI_EVENT_START_ELEMENT_GENERIC_UNDECLARED:
				break;
			case EXI_EVENT_END_ELEMENT_UNDECLARED:
				break;
			case EXI_EVENT_CHARACTERS_GENERIC:
				break;
			case EXI_EVENT_CHARACTERS_GENERIC_UNDECLARED:
				break;
			case EXI_EVENT_ATTRIBUTE_GENERIC:
				break;
			case EXI_EVENT_ATTRIBUTE_INVALID_VALUE:
				break;
			case EXI_EVENT_ATTRIBUTE_ANY_INVALID_VALUE:
				break;
			case EXI_EVENT_ATTRIBUTE_GENERIC_UNDECLARED:
				break;
			default:
				/* ERROR */
				return -1;
			}

		} while (noEndOfDocument);

	return 0;
}


/** 
 * \brief Takes the EXI stream, invokes the called service method, and provides the response EXI stream
 * \param	service   struct EXIService* Represent the service data structure
 * \param	inStream   uint8_t* EXI in stream
 * \param	sizeInStream   uint16_t Length of the inStream
 * \param	outStream   uint8_t* Represent the out stream
 * \param	sizeOutStream   uint16_t Size of the out stream
 * \param	outStreamLength   uint16_t* Length of the stream
 * \return  0 = 0K; -1 = ERROR
 */
int messageDispatcher(struct EXIService* service, uint8_t* inStream, uint16_t sizeInStream, uint8_t* outStream, uint16_t sizeOutStream, uint16_t* outStreamLength)
{
	struct MessageHeaderType header;	
	struct SignatureType signature;

	uint32_t inPos, outPos;
	
	exi_name_table_runtime_t runtimeTableDecode;
	exi_name_table_runtime_t runtimeTableEncode;
	
	/* assign inStream data to service EXI structure */
	inPos = service->transportHeaderOffset;
	service->inStream.data = inStream;
	service->inStream.size = sizeInStream+inPos;
	service->inStream.pos = &inPos;
	service->inStream.buffer=0;
	service->inStream.capacity=0;

	
	/* assign outStream data to service EXI structure */
	outPos=service->transportHeaderOffset;
	service->outStream.data = outStream;
	service->outStream.size = sizeOutStream;
	service->outStream.pos = &outPos;
	service->outStream.buffer=0;
	service->outStream.capacity=8;
	
	/* clear error code */
	service->errorCode = 0;
	
	/* init decoder (read header, set initial state) */
	/* init runtime table */
	exiInitNameTableRuntime(&runtimeTableDecode);
	exiInitDecoder(&(service->inStream), &(service->stateDecode), runtimeTableDecode);
	
	/* init encoder (write header, set initial state) */
	exiInitNameTableRuntime(&runtimeTableEncode);
	exiInitEncoder(&(service->outStream), &(service->stateEncode), runtimeTableEncode);

	/* init uniqueID stack */
	service->idPath.pos=0;

	init_MessageHeaderType(&header);
	service->exiMsg.V2G_Message.Header = &header;
	init_SignatureType(&signature);
	service->exiMsg.V2G_Message.Header->Signature=&signature;

	/* init EXI message */
	init_EXIDocumentType(&(service->exiMsg));

	/* deserialize the input stream and call the corresponding service */
	if(deserializeMessage(service))
	{
		return -1; /* something went wrong */
	}

	/* determine payload size (without transport offset) */	
	outPos -= service->transportHeaderOffset;
	*outStreamLength = outPos;

	
	return 0;
}

/** 
 * \brief Init the v2g service data structure
 * \param	service   struct EXIService* Service data structure
 * \param	bytes   bytes_t setted up byte data structure
 * \param	string_ucs_t   setted up string data structure
 * \param	transportHeaderOffset uint16_t Transport protocol offset
 * \return  0 = 0K; -1 = ERROR
 */
int init_v2gservice(struct EXIService* service, bytes_t bytes, string_ucs_t string, uint16_t transportHeaderOffset)
{

	/* init byte array */
	 service->val.binary = bytes;

	/* init string array */
	 service->val.string = string;

	/* init offset for transport protocoll */
	 service->transportHeaderOffset=transportHeaderOffset;

	return 0;
}