/*
* 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 .
*/
/*******************************************************************
*
* @author Sebastian.Kaebisch.EXT@siemens.com
* @version 0.6
* @contact Joerg.Heuer@siemens.com
*
* Code generated by EXISeGen
*
********************************************************************/
#include "v2g_service.h"
#include "v2g_serviceDataTypes.h"
#include "EXITypes.h"
#include "EXIEncoder.h"
#include
static int serialize_NotificationType(struct NotificationType* type, struct EXIService* service)
{
/* element ID assignment of FaultCode*/
service->eqn.namespaceURI=6;
service->eqn.localPart=74;
/* encode start element FaultCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->FaultCode;
/* encode character FaultCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of FaultCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.FaultMsg)
{
/* element ID assignment of FaultMsg*/
service->eqn.namespaceURI=6;
service->eqn.localPart=75;
/* encode start element FaultMsg */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->FaultMsg.arraylen.data;
memcpy(service->val.string.codepoints, type->FaultMsg.data,type->FaultMsg.arraylen.data*sizeof(uint32_t));
/* encode character FaultMsg */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of FaultMsg */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_CanonicalizationMethodType(struct CanonicalizationMethodType* type, struct EXIService* service)
{
/* element ID assignment of attr_Algorithm*/
service->eqn.namespaceURI=0;
service->eqn.localPart=0;
service->val.type = STRING;
service->val.string.len = type->attr_Algorithm.arraylen.data;
service->val.string.codepoints= type->attr_Algorithm.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
return 0;
}
static int serialize_SignatureMethodType(struct SignatureMethodType* type, struct EXIService* service)
{
/* element ID assignment of attr_Algorithm*/
service->eqn.namespaceURI=0;
service->eqn.localPart=0;
service->val.type = STRING;
service->val.string.len = type->attr_Algorithm.arraylen.data;
service->val.string.codepoints= type->attr_Algorithm.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
return 0;
}
static int serialize_DigestMethodType(struct DigestMethodType* type, struct EXIService* service)
{
/* element ID assignment of attr_Algorithm*/
service->eqn.namespaceURI=0;
service->eqn.localPart=0;
service->val.type = STRING;
service->val.string.len = type->attr_Algorithm.arraylen.data;
service->val.string.codepoints= type->attr_Algorithm.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
return 0;
}
static int serialize_ReferenceType(struct ReferenceType* type, struct EXIService* service)
{
if(type->isused.attr_URI)
{
/* element ID assignment of attr_URI*/
service->eqn.namespaceURI=0;
service->eqn.localPart=7;
service->val.type = STRING;
service->val.string.len = type->attr_URI.arraylen.data;
service->val.string.codepoints= type->attr_URI.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
}
/* element ID assignment of DigestMethod*/
service->eqn.namespaceURI=4;
service->eqn.localPart=5;
/* encode start element DigestMethod */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DigestMethod */
if(serialize_DigestMethodType( &(type->DigestMethod),service))
{
return -1;
}
/* encode end element of DigestMethod */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of DigestValue*/
service->eqn.namespaceURI=4;
service->eqn.localPart=7;
/* encode start element DigestValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->DigestValue.arraylen.data;
memcpy(service->val.binary.data, type->DigestValue.data,type->DigestValue.arraylen.data);
/* encode character DigestValue */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of DigestValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_SignedInfoType(struct SignedInfoType* type, struct EXIService* service)
{
/* element ID assignment of CanonicalizationMethod*/
service->eqn.namespaceURI=4;
service->eqn.localPart=0;
/* encode start element CanonicalizationMethod */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CanonicalizationMethod */
if(serialize_CanonicalizationMethodType( &(type->CanonicalizationMethod),service))
{
return -1;
}
/* encode end element of CanonicalizationMethod */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of SignatureMethod*/
service->eqn.namespaceURI=4;
service->eqn.localPart=43;
/* encode start element SignatureMethod */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SignatureMethod */
if(serialize_SignatureMethodType( &(type->SignatureMethod),service))
{
return -1;
}
/* encode end element of SignatureMethod */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of Reference*/
service->eqn.namespaceURI=4;
service->eqn.localPart=34;
/* encode start element Reference */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of Reference */
if(serialize_ReferenceType(&(type->Reference[0]),service))
{
return -1;
}
/* encode end element of Reference */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_X509IssuerSerialType(struct X509IssuerSerialType* type, struct EXIService* service)
{
/* element ID assignment of X509IssuerName*/
service->eqn.namespaceURI=4;
service->eqn.localPart=62;
/* encode start element X509IssuerName */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->X509IssuerName.arraylen.data;
memcpy(service->val.string.codepoints, type->X509IssuerName.data,type->X509IssuerName.arraylen.data*sizeof(uint32_t));
/* encode character X509IssuerName */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of X509IssuerName */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of X509SerialNumber*/
service->eqn.namespaceURI=4;
service->eqn.localPart=66;
/* encode start element X509SerialNumber */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int64=type->X509SerialNumber;
service->val.integer.type = INTEGER_64;
/* encode character X509SerialNumber */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of X509SerialNumber */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_X509DataType(struct X509DataType* type, struct EXIService* service)
{
/* element ID assignment of X509IssuerSerial*/
service->eqn.namespaceURI=4;
service->eqn.localPart=63;
/* encode start element X509IssuerSerial */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of X509IssuerSerial */
if(serialize_X509IssuerSerialType( &(type->X509IssuerSerial),service))
{
return -1;
}
/* encode end element of X509IssuerSerial */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of X509SKI*/
service->eqn.namespaceURI=4;
service->eqn.localPart=65;
/* encode start element X509SKI */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->X509SKI.arraylen.data;
memcpy(service->val.binary.data, type->X509SKI.data,type->X509SKI.arraylen.data);
/* encode character X509SKI */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of X509SKI */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of X509SubjectName*/
service->eqn.namespaceURI=4;
service->eqn.localPart=67;
/* encode start element X509SubjectName */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->X509SubjectName.arraylen.data;
memcpy(service->val.string.codepoints, type->X509SubjectName.data,type->X509SubjectName.arraylen.data*sizeof(uint32_t));
/* encode character X509SubjectName */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of X509SubjectName */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of X509Certificate*/
service->eqn.namespaceURI=4;
service->eqn.localPart=59;
/* encode start element X509Certificate */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->X509Certificate.arraylen.data;
memcpy(service->val.binary.data, type->X509Certificate.data,type->X509Certificate.arraylen.data);
/* encode character X509Certificate */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of X509Certificate */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of X509CRL*/
service->eqn.namespaceURI=4;
service->eqn.localPart=58;
/* encode start element X509CRL */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->X509CRL.arraylen.data;
memcpy(service->val.binary.data, type->X509CRL.data,type->X509CRL.arraylen.data);
/* encode character X509CRL */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of X509CRL */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_KeyInfoType(struct KeyInfoType* type, struct EXIService* service)
{
if(type->isused.attr_Id)
{
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
}
/* element ID assignment of X509Data*/
service->eqn.namespaceURI=4;
service->eqn.localPart=60;
/* encode start element X509Data */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of X509Data */
if(serialize_X509DataType( &(type->X509Data),service))
{
return -1;
}
/* encode end element of X509Data */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_SignatureType(struct SignatureType* type, struct EXIService* service)
{
if(type->isused.attr_Id)
{
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
}
/* element ID assignment of SignedInfo*/
service->eqn.namespaceURI=4;
service->eqn.localPart=52;
/* encode start element SignedInfo */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SignedInfo */
if(serialize_SignedInfoType( &(type->SignedInfo),service))
{
return -1;
}
/* encode end element of SignedInfo */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of SignatureValue*/
service->eqn.namespaceURI=4;
service->eqn.localPart=50;
/* encode start element SignatureValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->SignatureValue.arraylen.data;
service->val.binary.data= type->SignatureValue.data;
/* encode character DigestValue */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SignatureValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.KeyInfo)
{
/* element ID assignment of KeyInfo*/
service->eqn.namespaceURI=4;
service->eqn.localPart=14;
/* encode start element KeyInfo */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of KeyInfo */
if(serialize_KeyInfoType( &(type->KeyInfo),service))
{
return -1;
}
/* encode end element of KeyInfo */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_MessageHeaderType(struct MessageHeaderType* type, struct EXIService* service)
{
/* element ID assignment of SessionID*/
service->eqn.namespaceURI=8;
service->eqn.localPart=2;
/* encode start element SessionID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_HEX;
service->val.binary.len = type->SessionID.arraylen.data;
memcpy(service->val.binary.data, type->SessionID.data,type->SessionID.arraylen.data);
/* encode character SessionID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SessionID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.Notification)
{
/* element ID assignment of Notification*/
service->eqn.namespaceURI=8;
service->eqn.localPart=1;
/* encode start element Notification */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of Notification */
if(serialize_NotificationType( &(type->Notification),service))
{
return -1;
}
/* encode end element of Notification */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.Signature)
{
/* element ID assignment of Signature*/
service->eqn.namespaceURI=4;
service->eqn.localPart=42;
/* encode start element Signature */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of Signature */
if(serialize_SignatureType( (type->Signature),service))
{
return -1;
}
/* encode end element of Signature */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_SessionSetupReqType(struct SessionSetupReqType* type, struct EXIService* service)
{
/* element ID assignment of EVCCID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=41;
/* encode start element EVCCID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_HEX;
service->val.binary.len = type->EVCCID.arraylen.data;
memcpy(service->val.binary.data, type->EVCCID.data,type->EVCCID.arraylen.data);
/* encode character EVCCID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVCCID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_SessionSetupResType(struct SessionSetupResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=47;
/* encode start element EVSEID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_HEX;
service->val.binary.len = type->EVSEID.arraylen.data;
memcpy(service->val.binary.data, type->EVSEID.data,type->EVSEID.arraylen.data);
/* encode character EVSEID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVSEID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.DateTimeNow)
{
/* element ID assignment of DateTimeNow*/
service->eqn.namespaceURI=5;
service->eqn.localPart=40;
/* encode start element DateTimeNow */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int64=type->DateTimeNow;
service->val.integer.type = INTEGER_64;
/* encode character DateTimeNow */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of DateTimeNow */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ServiceDiscoveryReqType(struct ServiceDiscoveryReqType* type, struct EXIService* service)
{
if(type->isused.ServiceScope)
{
/* element ID assignment of ServiceScope*/
service->eqn.namespaceURI=5;
service->eqn.localPart=104;
/* encode start element ServiceScope */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->ServiceScope.arraylen.data;
memcpy(service->val.string.codepoints, type->ServiceScope.data,type->ServiceScope.arraylen.data*sizeof(uint32_t));
/* encode character ServiceScope */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceScope */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServiceCategory)
{
/* element ID assignment of ServiceCategory*/
service->eqn.namespaceURI=5;
service->eqn.localPart=88;
/* encode start element ServiceCategory */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ServiceCategory;
/* encode character ServiceCategory */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceCategory */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_PaymentOptionsType(struct PaymentOptionsType* type, struct EXIService* service)
{
size_t i_loop;
for(i_loop=0;i_loop < type->arraylen.PaymentOption;i_loop++)
{
/* element ID assignment of PaymentOption*/
service->eqn.namespaceURI=6;
service->eqn.localPart=99;
/* encode start element PaymentOption */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->PaymentOption[i_loop];
/* encode character PaymentOption */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of PaymentOption */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ServiceTagType(struct ServiceTagType* type, struct EXIService* service)
{
/* element ID assignment of ServiceID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=130;
/* encode start element ServiceID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint16=type->ServiceID;
service->val.integer.type = UNSIGNED_INTEGER_16;
/* encode character ServiceID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.ServiceName)
{
/* element ID assignment of ServiceName*/
service->eqn.namespaceURI=6;
service->eqn.localPart=131;
/* encode start element ServiceName */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->ServiceName.arraylen.data;
memcpy(service->val.string.codepoints, type->ServiceName.data,type->ServiceName.arraylen.data*sizeof(uint32_t));
/* encode character ServiceName */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceName */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServiceCategory)
{
/* element ID assignment of ServiceCategory*/
service->eqn.namespaceURI=6;
service->eqn.localPart=127;
/* encode start element ServiceCategory */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ServiceCategory;
/* encode character ServiceCategory */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceCategory */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServiceScope)
{
/* element ID assignment of ServiceScope*/
service->eqn.namespaceURI=6;
service->eqn.localPart=133;
/* encode start element ServiceScope */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->ServiceScope.arraylen.data;
memcpy(service->val.string.codepoints, type->ServiceScope.data,type->ServiceScope.arraylen.data*sizeof(uint32_t));
/* encode character ServiceScope */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceScope */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ServiceChargeType(struct ServiceChargeType* type, struct EXIService* service)
{
/* element ID assignment of ServiceTag*/
service->eqn.namespaceURI=6;
service->eqn.localPart=134;
/* encode start element ServiceTag */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServiceTag */
if(serialize_ServiceTagType( &(type->ServiceTag),service))
{
return -1;
}
/* encode end element of ServiceTag */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of FreeService*/
service->eqn.namespaceURI=6;
service->eqn.localPart=76;
/* encode start element FreeService */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->FreeService;
/* encode character FreeService */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of FreeService */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EnergyTransferType*/
service->eqn.namespaceURI=6;
service->eqn.localPart=71;
/* encode start element EnergyTransferType */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->EnergyTransferType;
/* encode character EnergyTransferType */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EnergyTransferType */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ServiceType(struct ServiceType* type, struct EXIService* service)
{
/* element ID assignment of ServiceTag*/
service->eqn.namespaceURI=6;
service->eqn.localPart=134;
/* encode start element ServiceTag */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServiceTag */
if(serialize_ServiceTagType( &(type->ServiceTag),service))
{
return -1;
}
/* encode end element of ServiceTag */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of FreeService*/
service->eqn.namespaceURI=6;
service->eqn.localPart=76;
/* encode start element FreeService */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->FreeService;
/* encode character FreeService */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of FreeService */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ServiceTagListType(struct ServiceTagListType* type, struct EXIService* service)
{
size_t i_loop;
for(i_loop=0;i_loop < type->arraylen.Service;i_loop++)
{
/* element ID assignment of Service*/
service->eqn.namespaceURI=6;
service->eqn.localPart=126;
/* encode start element Service */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of Service */
if(serialize_ServiceType(&(type->Service[i_loop]),service))
{
return -1;
}
/* encode end element of Service */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ServiceDiscoveryResType(struct ServiceDiscoveryResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of PaymentOptions*/
service->eqn.namespaceURI=5;
service->eqn.localPart=70;
/* encode start element PaymentOptions */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PaymentOptions */
if(serialize_PaymentOptionsType( &(type->PaymentOptions),service))
{
return -1;
}
/* encode end element of PaymentOptions */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ChargeService*/
service->eqn.namespaceURI=5;
service->eqn.localPart=18;
/* encode start element ChargeService */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ChargeService */
if(serialize_ServiceChargeType( &(type->ChargeService),service))
{
return -1;
}
/* encode end element of ChargeService */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.ServiceList)
{
/* element ID assignment of ServiceList*/
service->eqn.namespaceURI=5;
service->eqn.localPart=98;
/* encode start element ServiceList */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServiceList */
if(serialize_ServiceTagListType( &(type->ServiceList),service))
{
return -1;
}
/* encode end element of ServiceList */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ServiceDetailReqType(struct ServiceDetailReqType* type, struct EXIService* service)
{
/* element ID assignment of ServiceID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=97;
/* encode start element ServiceID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint16=type->ServiceID;
service->val.integer.type = UNSIGNED_INTEGER_16;
/* encode character ServiceID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_PhysicalValueType(struct PhysicalValueType* type, struct EXIService* service)
{
/* element ID assignment of Multiplier*/
service->eqn.namespaceURI=6;
service->eqn.localPart=84;
/* encode start element Multiplier */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = NBIT_UNSIGNED_INTEGER;
service->val.integer.val.int8=type->Multiplier;
service->val.integer.type = INTEGER_8;
/* encode character Multiplier */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of Multiplier */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.Unit)
{
/* element ID assignment of Unit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=145;
/* encode start element Unit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->Unit;
/* encode character Unit */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of Unit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of Value*/
service->eqn.namespaceURI=6;
service->eqn.localPart=146;
/* encode start element Value */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->Value;
service->val.integer.type = INTEGER_16;
/* encode character Value */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of Value */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ParameterType(struct ParameterType* type, struct EXIService* service)
{
/* element ID assignment of attr_Name*/
service->eqn.namespaceURI=0;
service->eqn.localPart=4;
service->val.type = STRING;
service->val.string.len = type->attr_Name.arraylen.data;
service->val.string.codepoints= type->attr_Name.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
/* element ID assignment of attr_ValueType*/
service->eqn.namespaceURI=0;
service->eqn.localPart=8;
service->val.type = STRING;
service->val.string.len = type->attr_ValueType.arraylen.data;
service->val.string.codepoints= type->attr_ValueType.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
/* element ID assignment of boolValue*/
service->eqn.namespaceURI=6;
service->eqn.localPart=149;
/* encode start element boolValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->boolValue;
/* encode character boolValue */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of boolValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of byteValue*/
service->eqn.namespaceURI=6;
service->eqn.localPart=150;
/* encode start element byteValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = NBIT_UNSIGNED_INTEGER;
service->val.integer.val.int8=type->byteValue;
service->val.integer.type = INTEGER_8;
/* encode character byteValue */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of byteValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of shortValue*/
service->eqn.namespaceURI=6;
service->eqn.localPart=177;
/* encode start element shortValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->shortValue;
service->val.integer.type = INTEGER_16;
/* encode character shortValue */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of shortValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of intValue*/
service->eqn.namespaceURI=6;
service->eqn.localPart=162;
/* encode start element intValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int32=type->intValue;
service->val.integer.type = INTEGER_32;
/* encode character intValue */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of intValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of physicalValue*/
service->eqn.namespaceURI=6;
service->eqn.localPart=168;
/* encode start element physicalValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of physicalValue */
if(serialize_PhysicalValueType( &(type->physicalValue),service))
{
return -1;
}
/* encode end element of physicalValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of stringValue*/
service->eqn.namespaceURI=6;
service->eqn.localPart=181;
/* encode start element stringValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->stringValue.arraylen.data;
memcpy(service->val.string.codepoints, type->stringValue.data,type->stringValue.arraylen.data*sizeof(uint32_t));
/* encode character stringValue */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of stringValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ParameterSetType(struct ParameterSetType* type, struct EXIService* service)
{
size_t i_loop;
/* element ID assignment of ParameterSetID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=96;
/* encode start element ParameterSetID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->ParameterSetID;
service->val.integer.type = INTEGER_16;
/* encode character ParameterSetID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ParameterSetID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
for(i_loop=0;i_loop < type->arraylen.Parameter;i_loop++)
{
/* element ID assignment of Parameter*/
service->eqn.namespaceURI=6;
service->eqn.localPart=94;
/* encode start element Parameter */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of Parameter */
if(serialize_ParameterType(&(type->Parameter[i_loop]),service))
{
return -1;
}
/* encode end element of Parameter */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ServiceParameterListType(struct ServiceParameterListType* type, struct EXIService* service)
{
size_t i_loop;
for(i_loop=0;i_loop < type->arraylen.ParameterSet;i_loop++)
{
/* element ID assignment of ParameterSet*/
service->eqn.namespaceURI=6;
service->eqn.localPart=95;
/* encode start element ParameterSet */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ParameterSet */
if(serialize_ParameterSetType(&(type->ParameterSet[i_loop]),service))
{
return -1;
}
/* encode end element of ParameterSet */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ServiceDetailResType(struct ServiceDetailResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ServiceID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=97;
/* encode start element ServiceID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint16=type->ServiceID;
service->val.integer.type = UNSIGNED_INTEGER_16;
/* encode character ServiceID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.ServiceParameterList)
{
/* element ID assignment of ServiceParameterList*/
service->eqn.namespaceURI=5;
service->eqn.localPart=99;
/* encode start element ServiceParameterList */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServiceParameterList */
if(serialize_ServiceParameterListType( &(type->ServiceParameterList),service))
{
return -1;
}
/* encode end element of ServiceParameterList */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_SelectedServiceType(struct SelectedServiceType* type, struct EXIService* service)
{
/* element ID assignment of ServiceID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=130;
/* encode start element ServiceID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint16=type->ServiceID;
service->val.integer.type = UNSIGNED_INTEGER_16;
/* encode character ServiceID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ServiceID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.ParameterSetID)
{
/* element ID assignment of ParameterSetID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=96;
/* encode start element ParameterSetID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->ParameterSetID;
service->val.integer.type = INTEGER_16;
/* encode character ParameterSetID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ParameterSetID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_SelectedServiceListType(struct SelectedServiceListType* type, struct EXIService* service)
{
size_t i_loop;
for(i_loop=0;i_loop < type->arraylen.SelectedService;i_loop++)
{
/* element ID assignment of SelectedService*/
service->eqn.namespaceURI=6;
service->eqn.localPart=123;
/* encode start element SelectedService */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SelectedService */
if(serialize_SelectedServiceType(&(type->SelectedService[i_loop]),service))
{
return -1;
}
/* encode end element of SelectedService */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ServicePaymentSelectionReqType(struct ServicePaymentSelectionReqType* type, struct EXIService* service)
{
/* element ID assignment of SelectedPaymentOption*/
service->eqn.namespaceURI=5;
service->eqn.localPart=86;
/* encode start element SelectedPaymentOption */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->SelectedPaymentOption;
/* encode character SelectedPaymentOption */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SelectedPaymentOption */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of SelectedServiceList*/
service->eqn.namespaceURI=5;
service->eqn.localPart=87;
/* encode start element SelectedServiceList */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SelectedServiceList */
if(serialize_SelectedServiceListType( &(type->SelectedServiceList),service))
{
return -1;
}
/* encode end element of SelectedServiceList */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ServicePaymentSelectionResType(struct ServicePaymentSelectionResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_SubCertificatesType(struct SubCertificatesType* type, struct EXIService* service)
{
size_t i_loop;
for(i_loop=0;i_loop < type->arraylen.Certificate;i_loop++)
{
/* element ID assignment of Certificate*/
service->eqn.namespaceURI=6;
service->eqn.localPart=8;
/* encode start element Certificate */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->Certificate[i_loop].arraylen.data;
memcpy(service->val.binary.data, type->Certificate[i_loop].data,type->Certificate[i_loop].arraylen.data);
/* encode character Certificate */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of Certificate */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_CertificateChainType(struct CertificateChainType* type, struct EXIService* service)
{
/* element ID assignment of Certificate*/
service->eqn.namespaceURI=6;
service->eqn.localPart=8;
/* encode start element Certificate */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->Certificate.arraylen.data;
memcpy(service->val.binary.data, type->Certificate.data,type->Certificate.arraylen.data);
/* encode character Certificate */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of Certificate */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.SubCertificates)
{
/* element ID assignment of SubCertificates*/
service->eqn.namespaceURI=6;
service->eqn.localPart=141;
/* encode start element SubCertificates */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SubCertificates */
if(serialize_SubCertificatesType( &(type->SubCertificates),service))
{
return -1;
}
/* encode end element of SubCertificates */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_PaymentDetailsReqType(struct PaymentDetailsReqType* type, struct EXIService* service)
{
/* element ID assignment of ContractID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=30;
/* encode start element ContractID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->ContractID.arraylen.data;
memcpy(service->val.string.codepoints, type->ContractID.data,type->ContractID.arraylen.data*sizeof(uint32_t));
/* encode character ContractID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ContractID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractSignatureCertChain*/
service->eqn.namespaceURI=5;
service->eqn.localPart=31;
/* encode start element ContractSignatureCertChain */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ContractSignatureCertChain */
if(serialize_CertificateChainType( &(type->ContractSignatureCertChain),service))
{
return -1;
}
/* encode end element of ContractSignatureCertChain */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_PaymentDetailsResType(struct PaymentDetailsResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of GenChallenge*/
service->eqn.namespaceURI=5;
service->eqn.localPart=58;
/* encode start element GenChallenge */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->GenChallenge.arraylen.data;
memcpy(service->val.string.codepoints, type->GenChallenge.data,type->GenChallenge.arraylen.data*sizeof(uint32_t));
/* encode character GenChallenge */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of GenChallenge */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of DateTimeNow*/
service->eqn.namespaceURI=5;
service->eqn.localPart=40;
/* encode start element DateTimeNow */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int64=type->DateTimeNow;
service->val.integer.type = INTEGER_64;
/* encode character DateTimeNow */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of DateTimeNow */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ContractAuthenticationReqType(struct ContractAuthenticationReqType* type, struct EXIService* service)
{
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
/* element ID assignment of GenChallenge*/
service->eqn.namespaceURI=5;
service->eqn.localPart=58;
/* encode start element GenChallenge */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->GenChallenge.arraylen.data;
memcpy(service->val.string.codepoints, type->GenChallenge.data,type->GenChallenge.arraylen.data*sizeof(uint32_t));
/* encode character GenChallenge */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of GenChallenge */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ContractAuthenticationResType(struct ContractAuthenticationResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_AC_EVChargeParameterType(struct AC_EVChargeParameterType* type, struct EXIService* service)
{
/* element ID assignment of DepartureTime*/
service->eqn.namespaceURI=6;
service->eqn.localPart=30;
/* encode start element DepartureTime */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint32=type->DepartureTime;
service->val.integer.type = UNSIGNED_INTEGER_32;
/* encode character DepartureTime */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of DepartureTime */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EAmount*/
service->eqn.namespaceURI=6;
service->eqn.localPart=31;
/* encode start element EAmount */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EAmount */
if(serialize_PhysicalValueType( &(type->EAmount),service))
{
return -1;
}
/* encode end element of EAmount */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVMaxVoltage*/
service->eqn.namespaceURI=6;
service->eqn.localPart=40;
/* encode start element EVMaxVoltage */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMaxVoltage */
if(serialize_PhysicalValueType( &(type->EVMaxVoltage),service))
{
return -1;
}
/* encode end element of EVMaxVoltage */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVMaxCurrent*/
service->eqn.namespaceURI=6;
service->eqn.localPart=39;
/* encode start element EVMaxCurrent */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMaxCurrent */
if(serialize_PhysicalValueType( &(type->EVMaxCurrent),service))
{
return -1;
}
/* encode end element of EVMaxCurrent */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVMinCurrent*/
service->eqn.namespaceURI=6;
service->eqn.localPart=44;
/* encode start element EVMinCurrent */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMinCurrent */
if(serialize_PhysicalValueType( &(type->EVMinCurrent),service))
{
return -1;
}
/* encode end element of EVMinCurrent */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_DC_EVStatusType(struct DC_EVStatusType* type, struct EXIService* service)
{
/* element ID assignment of EVReady*/
service->eqn.namespaceURI=6;
service->eqn.localPart=49;
/* encode start element EVReady */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->EVReady;
/* encode character EVReady */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVReady */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVCabinConditioning)
{
/* element ID assignment of EVCabinConditioning*/
service->eqn.namespaceURI=6;
service->eqn.localPart=33;
/* encode start element EVCabinConditioning */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->EVCabinConditioning;
/* encode character EVCabinConditioning */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVCabinConditioning */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.EVRESSConditioning)
{
/* element ID assignment of EVRESSConditioning*/
service->eqn.namespaceURI=6;
service->eqn.localPart=47;
/* encode start element EVRESSConditioning */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->EVRESSConditioning;
/* encode character EVRESSConditioning */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVRESSConditioning */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of EVErrorCode*/
service->eqn.namespaceURI=6;
service->eqn.localPart=38;
/* encode start element EVErrorCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->EVErrorCode;
/* encode character EVErrorCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVErrorCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVRESSSOC*/
service->eqn.namespaceURI=6;
service->eqn.localPart=48;
/* encode start element EVRESSSOC */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = NBIT_UNSIGNED_INTEGER;
service->val.integer.val.int8=type->EVRESSSOC;
service->val.integer.type = INTEGER_8;
/* encode character EVRESSSOC */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVRESSSOC */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_DC_EVChargeParameterType(struct DC_EVChargeParameterType* type, struct EXIService* service)
{
/* element ID assignment of DC_EVStatus*/
service->eqn.namespaceURI=6;
service->eqn.localPart=28;
/* encode start element DC_EVStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVStatus */
if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
{
return -1;
}
/* encode end element of DC_EVStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVMaximumCurrentLimit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=41;
/* encode start element EVMaximumCurrentLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMaximumCurrentLimit */
if(serialize_PhysicalValueType( &(type->EVMaximumCurrentLimit),service))
{
return -1;
}
/* encode end element of EVMaximumCurrentLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVMaximumPowerLimit)
{
/* element ID assignment of EVMaximumPowerLimit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=42;
/* encode start element EVMaximumPowerLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMaximumPowerLimit */
if(serialize_PhysicalValueType( &(type->EVMaximumPowerLimit),service))
{
return -1;
}
/* encode end element of EVMaximumPowerLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of EVMaximumVoltageLimit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=43;
/* encode start element EVMaximumVoltageLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMaximumVoltageLimit */
if(serialize_PhysicalValueType( &(type->EVMaximumVoltageLimit),service))
{
return -1;
}
/* encode end element of EVMaximumVoltageLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVEnergyCapacity)
{
/* element ID assignment of EVEnergyCapacity*/
service->eqn.namespaceURI=6;
service->eqn.localPart=36;
/* encode start element EVEnergyCapacity */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVEnergyCapacity */
if(serialize_PhysicalValueType( &(type->EVEnergyCapacity),service))
{
return -1;
}
/* encode end element of EVEnergyCapacity */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.EVEnergyRequest)
{
/* element ID assignment of EVEnergyRequest*/
service->eqn.namespaceURI=6;
service->eqn.localPart=37;
/* encode start element EVEnergyRequest */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVEnergyRequest */
if(serialize_PhysicalValueType( &(type->EVEnergyRequest),service))
{
return -1;
}
/* encode end element of EVEnergyRequest */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.FullSOC)
{
/* element ID assignment of FullSOC*/
service->eqn.namespaceURI=6;
service->eqn.localPart=77;
/* encode start element FullSOC */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = NBIT_UNSIGNED_INTEGER;
service->val.integer.val.int8=type->FullSOC;
service->val.integer.type = INTEGER_8;
/* encode character FullSOC */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of FullSOC */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.BulkSOC)
{
/* element ID assignment of BulkSOC*/
service->eqn.namespaceURI=6;
service->eqn.localPart=7;
/* encode start element BulkSOC */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = NBIT_UNSIGNED_INTEGER;
service->val.integer.val.int8=type->BulkSOC;
service->val.integer.type = INTEGER_8;
/* encode character BulkSOC */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of BulkSOC */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ChargeParameterDiscoveryReqType(struct ChargeParameterDiscoveryReqType* type, struct EXIService* service)
{
/* element ID assignment of EVRequestedEnergyTransferType*/
service->eqn.namespaceURI=5;
service->eqn.localPart=45;
/* encode start element EVRequestedEnergyTransferType */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->EVRequestedEnergyTransferType;
/* encode character EVRequestedEnergyTransferType */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVRequestedEnergyTransferType */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.AC_EVChargeParameter)
{
/* element ID assignment of AC_EVChargeParameter*/
service->eqn.namespaceURI=6;
service->eqn.localPart=0;
/* encode start element AC_EVChargeParameter */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of AC_EVChargeParameter */
if(serialize_AC_EVChargeParameterType( (type->AC_EVChargeParameter),service))
{
return -1;
}
/* encode end element of AC_EVChargeParameter */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.DC_EVChargeParameter)
{
/* element ID assignment of DC_EVChargeParameter*/
service->eqn.namespaceURI=6;
service->eqn.localPart=18;
/* encode start element DC_EVChargeParameter */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVChargeParameter */
if(serialize_DC_EVChargeParameterType( (type->DC_EVChargeParameter),service))
{
return -1;
}
/* encode end element of DC_EVChargeParameter */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_RelativeTimeIntervalType(struct RelativeTimeIntervalType* type, struct EXIService* service)
{
/* element ID assignment of start*/
service->eqn.namespaceURI=6;
service->eqn.localPart=179;
/* encode start element start */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint32=type->start;
service->val.integer.type = UNSIGNED_INTEGER_32;
/* encode character start */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of start */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.duration)
{
/* element ID assignment of duration*/
service->eqn.namespaceURI=6;
service->eqn.localPart=156;
/* encode start element duration */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint32=type->duration;
service->val.integer.type = UNSIGNED_INTEGER_32;
/* encode character duration */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of duration */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_PMaxScheduleEntryType(struct PMaxScheduleEntryType* type, struct EXIService* service)
{
/* element ID assignment of RelativeTimeInterval*/
service->eqn.namespaceURI=6;
service->eqn.localPart=106;
/* encode start element RelativeTimeInterval */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of RelativeTimeInterval */
if(serialize_RelativeTimeIntervalType( &(type->RelativeTimeInterval),service))
{
return -1;
}
/* encode end element of RelativeTimeInterval */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of PMax*/
service->eqn.namespaceURI=6;
service->eqn.localPart=87;
/* encode start element PMax */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->PMax;
service->val.integer.type = INTEGER_16;
/* encode character PMax */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of PMax */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_PMaxScheduleType(struct PMaxScheduleType* type, struct EXIService* service)
{
size_t i_loop;
/* element ID assignment of PMaxScheduleID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=91;
/* encode start element PMaxScheduleID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->PMaxScheduleID;
service->val.integer.type = INTEGER_16;
/* encode character PMaxScheduleID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of PMaxScheduleID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
for(i_loop=0;i_loop < type->arraylen.PMaxScheduleEntry;i_loop++)
{
/* element ID assignment of PMaxScheduleEntry*/
service->eqn.namespaceURI=6;
service->eqn.localPart=89;
/* encode start element PMaxScheduleEntry */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PMaxScheduleEntry */
if(serialize_PMaxScheduleEntryType(&(type->PMaxScheduleEntry[i_loop]),service))
{
return -1;
}
/* encode end element of PMaxScheduleEntry */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_CostType(struct CostType* type, struct EXIService* service)
{
/* element ID assignment of costKind*/
service->eqn.namespaceURI=6;
service->eqn.localPart=153;
/* encode start element costKind */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->costKind;
/* encode character costKind */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of costKind */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of amount*/
service->eqn.namespaceURI=6;
service->eqn.localPart=147;
/* encode start element amount */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint32=type->amount;
service->val.integer.type = UNSIGNED_INTEGER_32;
/* encode character amount */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of amount */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.amountMultiplier)
{
/* element ID assignment of amountMultiplier*/
service->eqn.namespaceURI=6;
service->eqn.localPart=148;
/* encode start element amountMultiplier */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = NBIT_UNSIGNED_INTEGER;
service->val.integer.val.int8=type->amountMultiplier;
service->val.integer.type = INTEGER_8;
/* encode character amountMultiplier */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of amountMultiplier */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ConsumptionCostType(struct ConsumptionCostType* type, struct EXIService* service)
{
size_t i_loop;
/* element ID assignment of startValue*/
service->eqn.namespaceURI=6;
service->eqn.localPart=180;
/* encode start element startValue */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint32=type->startValue;
service->val.integer.type = UNSIGNED_INTEGER_32;
/* encode character startValue */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of startValue */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.Cost)
{
for(i_loop=0;i_loop < type->arraylen.Cost;i_loop++)
{
/* element ID assignment of Cost*/
service->eqn.namespaceURI=6;
service->eqn.localPart=16;
/* encode start element Cost */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of Cost */
if(serialize_CostType(&(type->Cost[i_loop]),service))
{
return -1;
}
/* encode end element of Cost */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
}
return 0;
}
static int serialize_SalesTariffEntryType(struct SalesTariffEntryType* type, struct EXIService* service)
{
size_t i_loop;
/* element ID assignment of RelativeTimeInterval*/
service->eqn.namespaceURI=6;
service->eqn.localPart=106;
/* encode start element RelativeTimeInterval */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of RelativeTimeInterval */
if(serialize_RelativeTimeIntervalType( &(type->RelativeTimeInterval),service))
{
return -1;
}
/* encode end element of RelativeTimeInterval */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EPriceLevel*/
service->eqn.namespaceURI=6;
service->eqn.localPart=32;
/* encode start element EPriceLevel */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = NBIT_UNSIGNED_INTEGER;
service->val.integer.val.uint8=type->EPriceLevel;
service->val.integer.type = UNSIGNED_INTEGER_8;
/* encode character EPriceLevel */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EPriceLevel */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.ConsumptionCost)
{
for(i_loop=0;i_loop < type->arraylen.ConsumptionCost;i_loop++)
{
/* element ID assignment of ConsumptionCost*/
service->eqn.namespaceURI=6;
service->eqn.localPart=14;
/* encode start element ConsumptionCost */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ConsumptionCost */
if(serialize_ConsumptionCostType(&(type->ConsumptionCost[i_loop]),service))
{
return -1;
}
/* encode end element of ConsumptionCost */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
}
return 0;
}
static int serialize_SalesTariffType(struct SalesTariffType* type, struct EXIService* service)
{
size_t i_loop;
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
/* element ID assignment of SalesTariffID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=121;
/* encode start element SalesTariffID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->SalesTariffID;
service->val.integer.type = INTEGER_16;
/* encode character SalesTariffID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SalesTariffID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.SalesTariffDescription)
{
/* element ID assignment of SalesTariffDescription*/
service->eqn.namespaceURI=6;
service->eqn.localPart=118;
/* encode start element SalesTariffDescription */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->SalesTariffDescription.arraylen.data;
memcpy(service->val.string.codepoints, type->SalesTariffDescription.data,type->SalesTariffDescription.arraylen.data*sizeof(uint32_t));
/* encode character SalesTariffDescription */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SalesTariffDescription */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of NumEPriceLevels*/
service->eqn.namespaceURI=6;
service->eqn.localPart=86;
/* encode start element NumEPriceLevels */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = NBIT_UNSIGNED_INTEGER;
service->val.integer.val.uint8=type->NumEPriceLevels;
service->val.integer.type = UNSIGNED_INTEGER_8;
/* encode character NumEPriceLevels */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of NumEPriceLevels */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
for(i_loop=0;i_loop < type->arraylen.SalesTariffEntry;i_loop++)
{
/* element ID assignment of SalesTariffEntry*/
service->eqn.namespaceURI=6;
service->eqn.localPart=119;
/* encode start element SalesTariffEntry */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SalesTariffEntry */
if(serialize_SalesTariffEntryType(&(type->SalesTariffEntry[i_loop]),service))
{
return -1;
}
/* encode end element of SalesTariffEntry */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_SAScheduleTupleType(struct SAScheduleTupleType* type, struct EXIService* service)
{
/* element ID assignment of SAScheduleTupleID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=113;
/* encode start element SAScheduleTupleID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->SAScheduleTupleID;
service->val.integer.type = INTEGER_16;
/* encode character SAScheduleTupleID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SAScheduleTupleID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of PMaxSchedule*/
service->eqn.namespaceURI=6;
service->eqn.localPart=88;
/* encode start element PMaxSchedule */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PMaxSchedule */
if(serialize_PMaxScheduleType( &(type->PMaxSchedule),service))
{
return -1;
}
/* encode end element of PMaxSchedule */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.SalesTariff)
{
/* element ID assignment of SalesTariff*/
service->eqn.namespaceURI=6;
service->eqn.localPart=117;
/* encode start element SalesTariff */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SalesTariff */
if(serialize_SalesTariffType( (type->SalesTariff),service))
{
return -1;
}
/* encode end element of SalesTariff */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_SAScheduleListType(struct SAScheduleListType* type, struct EXIService* service)
{
size_t i_loop;
for(i_loop=0;i_loop < type->arraylen.SAScheduleTuple;i_loop++)
{
/* element ID assignment of SAScheduleTuple*/
service->eqn.namespaceURI=6;
service->eqn.localPart=112;
/* encode start element SAScheduleTuple */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SAScheduleTuple */
if(serialize_SAScheduleTupleType(&(type->SAScheduleTuple[i_loop]),service))
{
return -1;
}
/* encode end element of SAScheduleTuple */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_AC_EVSEStatusType(struct AC_EVSEStatusType* type, struct EXIService* service)
{
/* element ID assignment of PowerSwitchClosed*/
service->eqn.namespaceURI=6;
service->eqn.localPart=102;
/* encode start element PowerSwitchClosed */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->PowerSwitchClosed;
/* encode character PowerSwitchClosed */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of PowerSwitchClosed */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of RCD*/
service->eqn.namespaceURI=6;
service->eqn.localPart=105;
/* encode start element RCD */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->RCD;
/* encode character RCD */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of RCD */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ShutDownTime*/
service->eqn.namespaceURI=6;
service->eqn.localPart=138;
/* encode start element ShutDownTime */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint32=type->ShutDownTime;
service->val.integer.type = UNSIGNED_INTEGER_32;
/* encode character ShutDownTime */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ShutDownTime */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of StopCharging*/
service->eqn.namespaceURI=6;
service->eqn.localPart=140;
/* encode start element StopCharging */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->StopCharging;
/* encode character StopCharging */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of StopCharging */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_AC_EVSEChargeParameterType(struct AC_EVSEChargeParameterType* type, struct EXIService* service)
{
/* element ID assignment of AC_EVSEStatus*/
service->eqn.namespaceURI=6;
service->eqn.localPart=4;
/* encode start element AC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of AC_EVSEStatus */
if(serialize_AC_EVSEStatusType( &(type->AC_EVSEStatus),service))
{
return -1;
}
/* encode end element of AC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEMaxVoltage*/
service->eqn.namespaceURI=6;
service->eqn.localPart=57;
/* encode start element EVSEMaxVoltage */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaxVoltage */
if(serialize_PhysicalValueType( &(type->EVSEMaxVoltage),service))
{
return -1;
}
/* encode end element of EVSEMaxVoltage */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEMaxCurrent*/
service->eqn.namespaceURI=6;
service->eqn.localPart=56;
/* encode start element EVSEMaxCurrent */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaxCurrent */
if(serialize_PhysicalValueType( &(type->EVSEMaxCurrent),service))
{
return -1;
}
/* encode end element of EVSEMaxCurrent */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEMinCurrent*/
service->eqn.namespaceURI=6;
service->eqn.localPart=61;
/* encode start element EVSEMinCurrent */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMinCurrent */
if(serialize_PhysicalValueType( &(type->EVSEMinCurrent),service))
{
return -1;
}
/* encode end element of EVSEMinCurrent */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_DC_EVSEStatusType(struct DC_EVSEStatusType* type, struct EXIService* service)
{
if(type->isused.EVSEIsolationStatus)
{
/* element ID assignment of EVSEIsolationStatus*/
service->eqn.namespaceURI=6;
service->eqn.localPart=55;
/* encode start element EVSEIsolationStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->EVSEIsolationStatus;
/* encode character EVSEIsolationStatus */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVSEIsolationStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of EVSEStatusCode*/
service->eqn.namespaceURI=6;
service->eqn.localPart=66;
/* encode start element EVSEStatusCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->EVSEStatusCode;
/* encode character EVSEStatusCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVSEStatusCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_DC_EVSEChargeParameterType(struct DC_EVSEChargeParameterType* type, struct EXIService* service)
{
/* element ID assignment of DC_EVSEStatus*/
service->eqn.namespaceURI=6;
service->eqn.localPart=25;
/* encode start element DC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVSEStatus */
if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
{
return -1;
}
/* encode end element of DC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEMaximumCurrentLimit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=58;
/* encode start element EVSEMaximumCurrentLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaximumCurrentLimit */
if(serialize_PhysicalValueType( &(type->EVSEMaximumCurrentLimit),service))
{
return -1;
}
/* encode end element of EVSEMaximumCurrentLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVSEMaximumPowerLimit)
{
/* element ID assignment of EVSEMaximumPowerLimit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=59;
/* encode start element EVSEMaximumPowerLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaximumPowerLimit */
if(serialize_PhysicalValueType( &(type->EVSEMaximumPowerLimit),service))
{
return -1;
}
/* encode end element of EVSEMaximumPowerLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of EVSEMaximumVoltageLimit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=60;
/* encode start element EVSEMaximumVoltageLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaximumVoltageLimit */
if(serialize_PhysicalValueType( &(type->EVSEMaximumVoltageLimit),service))
{
return -1;
}
/* encode end element of EVSEMaximumVoltageLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEMinimumCurrentLimit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=62;
/* encode start element EVSEMinimumCurrentLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMinimumCurrentLimit */
if(serialize_PhysicalValueType( &(type->EVSEMinimumCurrentLimit),service))
{
return -1;
}
/* encode end element of EVSEMinimumCurrentLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEMinimumVoltageLimit*/
service->eqn.namespaceURI=6;
service->eqn.localPart=63;
/* encode start element EVSEMinimumVoltageLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMinimumVoltageLimit */
if(serialize_PhysicalValueType( &(type->EVSEMinimumVoltageLimit),service))
{
return -1;
}
/* encode end element of EVSEMinimumVoltageLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVSECurrentRegulationTolerance)
{
/* element ID assignment of EVSECurrentRegulationTolerance*/
service->eqn.namespaceURI=6;
service->eqn.localPart=53;
/* encode start element EVSECurrentRegulationTolerance */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSECurrentRegulationTolerance */
if(serialize_PhysicalValueType( &(type->EVSECurrentRegulationTolerance),service))
{
return -1;
}
/* encode end element of EVSECurrentRegulationTolerance */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of EVSEPeakCurrentRipple*/
service->eqn.namespaceURI=6;
service->eqn.localPart=64;
/* encode start element EVSEPeakCurrentRipple */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEPeakCurrentRipple */
if(serialize_PhysicalValueType( &(type->EVSEPeakCurrentRipple),service))
{
return -1;
}
/* encode end element of EVSEPeakCurrentRipple */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVSEEnergyToBeDelivered)
{
/* element ID assignment of EVSEEnergyToBeDelivered*/
service->eqn.namespaceURI=6;
service->eqn.localPart=54;
/* encode start element EVSEEnergyToBeDelivered */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEEnergyToBeDelivered */
if(serialize_PhysicalValueType( &(type->EVSEEnergyToBeDelivered),service))
{
return -1;
}
/* encode end element of EVSEEnergyToBeDelivered */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ChargeParameterDiscoveryResType(struct ChargeParameterDiscoveryResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.SAScheduleList)
{
/* element ID assignment of SAScheduleList*/
service->eqn.namespaceURI=6;
service->eqn.localPart=110;
/* encode start element SAScheduleList */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SAScheduleList */
if(serialize_SAScheduleListType( (type->SAScheduleList),service))
{
return -1;
}
/* encode end element of SAScheduleList */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.AC_EVSEChargeParameter)
{
/* element ID assignment of AC_EVSEChargeParameter*/
service->eqn.namespaceURI=6;
service->eqn.localPart=2;
/* encode start element AC_EVSEChargeParameter */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of AC_EVSEChargeParameter */
if(serialize_AC_EVSEChargeParameterType( (type->AC_EVSEChargeParameter),service))
{
return -1;
}
/* encode end element of AC_EVSEChargeParameter */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.DC_EVSEChargeParameter)
{
/* element ID assignment of DC_EVSEChargeParameter*/
service->eqn.namespaceURI=6;
service->eqn.localPart=23;
/* encode start element DC_EVSEChargeParameter */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVSEChargeParameter */
if(serialize_DC_EVSEChargeParameterType( (type->DC_EVSEChargeParameter),service))
{
return -1;
}
/* encode end element of DC_EVSEChargeParameter */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ProfileEntryType(struct ProfileEntryType* type, struct EXIService* service)
{
/* element ID assignment of ChargingProfileEntryStart*/
service->eqn.namespaceURI=6;
service->eqn.localPart=12;
/* encode start element ChargingProfileEntryStart */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = UNSIGNED_INTEGER;
service->val.integer.val.uint32=type->ChargingProfileEntryStart;
service->val.integer.type = UNSIGNED_INTEGER_32;
/* encode character ChargingProfileEntryStart */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ChargingProfileEntryStart */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ChargingProfileEntryMaxPower*/
service->eqn.namespaceURI=6;
service->eqn.localPart=11;
/* encode start element ChargingProfileEntryMaxPower */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->ChargingProfileEntryMaxPower;
service->val.integer.type = INTEGER_16;
/* encode character ChargingProfileEntryMaxPower */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ChargingProfileEntryMaxPower */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ChargingProfileType(struct ChargingProfileType* type, struct EXIService* service)
{
size_t i_loop;
/* element ID assignment of SAScheduleTupleID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=113;
/* encode start element SAScheduleTupleID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->SAScheduleTupleID;
service->val.integer.type = INTEGER_16;
/* encode character SAScheduleTupleID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SAScheduleTupleID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
for(i_loop=0;i_loop < type->arraylen.ProfileEntry;i_loop++)
{
/* element ID assignment of ProfileEntry*/
service->eqn.namespaceURI=6;
service->eqn.localPart=103;
/* encode start element ProfileEntry */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ProfileEntry */
if(serialize_ProfileEntryType(&(type->ProfileEntry[i_loop]),service))
{
return -1;
}
/* encode end element of ProfileEntry */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_DC_EVPowerDeliveryParameterType(struct DC_EVPowerDeliveryParameterType* type, struct EXIService* service)
{
/* element ID assignment of DC_EVStatus*/
service->eqn.namespaceURI=6;
service->eqn.localPart=28;
/* encode start element DC_EVStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVStatus */
if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
{
return -1;
}
/* encode end element of DC_EVStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.BulkChargingComplete)
{
/* element ID assignment of BulkChargingComplete*/
service->eqn.namespaceURI=6;
service->eqn.localPart=6;
/* encode start element BulkChargingComplete */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->BulkChargingComplete;
/* encode character BulkChargingComplete */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of BulkChargingComplete */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of ChargingComplete*/
service->eqn.namespaceURI=6;
service->eqn.localPart=10;
/* encode start element ChargingComplete */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->ChargingComplete;
/* encode character ChargingComplete */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ChargingComplete */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_PowerDeliveryReqType(struct PowerDeliveryReqType* type, struct EXIService* service)
{
/* element ID assignment of ReadyToChargeState*/
service->eqn.namespaceURI=5;
service->eqn.localPart=79;
/* encode start element ReadyToChargeState */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->ReadyToChargeState;
/* encode character ReadyToChargeState */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ReadyToChargeState */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.ChargingProfile)
{
/* element ID assignment of ChargingProfile*/
service->eqn.namespaceURI=5;
service->eqn.localPart=20;
/* encode start element ChargingProfile */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ChargingProfile */
if(serialize_ChargingProfileType( &(type->ChargingProfile),service))
{
return -1;
}
/* encode end element of ChargingProfile */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.DC_EVPowerDeliveryParameter)
{
/* element ID assignment of DC_EVPowerDeliveryParameter*/
service->eqn.namespaceURI=6;
service->eqn.localPart=21;
/* encode start element DC_EVPowerDeliveryParameter */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVPowerDeliveryParameter */
if(serialize_DC_EVPowerDeliveryParameterType( (type->DC_EVPowerDeliveryParameter),service))
{
return -1;
}
/* encode end element of DC_EVPowerDeliveryParameter */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_PowerDeliveryResType(struct PowerDeliveryResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.AC_EVSEStatus)
{
/* element ID assignment of AC_EVSEStatus*/
service->eqn.namespaceURI=6;
service->eqn.localPart=4;
/* encode start element AC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of AC_EVSEStatus */
if(serialize_AC_EVSEStatusType( (type->AC_EVSEStatus),service))
{
return -1;
}
/* encode end element of AC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.DC_EVSEStatus)
{
/* element ID assignment of DC_EVSEStatus*/
service->eqn.namespaceURI=6;
service->eqn.localPart=25;
/* encode start element DC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVSEStatus */
if(serialize_DC_EVSEStatusType( (type->DC_EVSEStatus),service))
{
return -1;
}
/* encode end element of DC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ChargingStatusReqType(struct ChargingStatusReqType* type, struct EXIService* service)
{
return 0;
}
static int serialize_MeterInfoType(struct MeterInfoType* type, struct EXIService* service)
{
/* element ID assignment of MeterID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=80;
/* encode start element MeterID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->MeterID.arraylen.data;
memcpy(service->val.string.codepoints, type->MeterID.data,type->MeterID.arraylen.data*sizeof(uint32_t));
/* encode character MeterID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of MeterID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.MeterReading)
{
/* element ID assignment of MeterReading*/
service->eqn.namespaceURI=6;
service->eqn.localPart=82;
/* encode start element MeterReading */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of MeterReading */
if(serialize_PhysicalValueType( &(type->MeterReading),service))
{
return -1;
}
/* encode end element of MeterReading */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.SigMeterReading)
{
/* element ID assignment of SigMeterReading*/
service->eqn.namespaceURI=6;
service->eqn.localPart=139;
/* encode start element SigMeterReading */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->SigMeterReading.arraylen.data;
memcpy(service->val.binary.data, type->SigMeterReading.data,type->SigMeterReading.arraylen.data);
/* encode character SigMeterReading */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SigMeterReading */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.MeterStatus)
{
/* element ID assignment of MeterStatus*/
service->eqn.namespaceURI=6;
service->eqn.localPart=83;
/* encode start element MeterStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->MeterStatus;
service->val.integer.type = INTEGER_16;
/* encode character MeterStatus */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of MeterStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.TMeter)
{
/* element ID assignment of TMeter*/
service->eqn.namespaceURI=6;
service->eqn.localPart=143;
/* encode start element TMeter */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int64=type->TMeter;
service->val.integer.type = INTEGER_64;
/* encode character TMeter */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of TMeter */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_ChargingStatusResType(struct ChargingStatusResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=47;
/* encode start element EVSEID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_HEX;
service->val.binary.len = type->EVSEID.arraylen.data;
memcpy(service->val.binary.data, type->EVSEID.data,type->EVSEID.arraylen.data);
/* encode character EVSEID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVSEID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of SAScheduleTupleID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=85;
/* encode start element SAScheduleTupleID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->SAScheduleTupleID;
service->val.integer.type = INTEGER_16;
/* encode character SAScheduleTupleID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SAScheduleTupleID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVSEMaxCurrent)
{
/* element ID assignment of EVSEMaxCurrent*/
service->eqn.namespaceURI=5;
service->eqn.localPart=48;
/* encode start element EVSEMaxCurrent */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaxCurrent */
if(serialize_PhysicalValueType( &(type->EVSEMaxCurrent),service))
{
return -1;
}
/* encode end element of EVSEMaxCurrent */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.MeterInfo)
{
/* element ID assignment of MeterInfo*/
service->eqn.namespaceURI=5;
service->eqn.localPart=60;
/* encode start element MeterInfo */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of MeterInfo */
if(serialize_MeterInfoType( &(type->MeterInfo),service))
{
return -1;
}
/* encode end element of MeterInfo */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of ReceiptRequired*/
service->eqn.namespaceURI=5;
service->eqn.localPart=80;
/* encode start element ReceiptRequired */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->ReceiptRequired;
/* encode character ReceiptRequired */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ReceiptRequired */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of AC_EVSEStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=0;
/* encode start element AC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of AC_EVSEStatus */
if(serialize_AC_EVSEStatusType( &(type->AC_EVSEStatus),service))
{
return -1;
}
/* encode end element of AC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_MeteringReceiptReqType(struct MeteringReceiptReqType* type, struct EXIService* service)
{
if(type->isused.attr_Id)
{
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
}
/* element ID assignment of SessionID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=105;
/* encode start element SessionID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_HEX;
service->val.binary.len = type->SessionID.arraylen.data;
memcpy(service->val.binary.data, type->SessionID.data,type->SessionID.arraylen.data);
/* encode character SessionID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SessionID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of SAScheduleTupleID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=85;
/* encode start element SAScheduleTupleID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->SAScheduleTupleID;
service->val.integer.type = INTEGER_16;
/* encode character SAScheduleTupleID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of SAScheduleTupleID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of MeterInfo*/
service->eqn.namespaceURI=5;
service->eqn.localPart=60;
/* encode start element MeterInfo */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of MeterInfo */
if(serialize_MeterInfoType( &(type->MeterInfo),service))
{
return -1;
}
/* encode end element of MeterInfo */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_MeteringReceiptResType(struct MeteringReceiptResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of AC_EVSEStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=0;
/* encode start element AC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of AC_EVSEStatus */
if(serialize_AC_EVSEStatusType( &(type->AC_EVSEStatus),service))
{
return -1;
}
/* encode end element of AC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_SessionStopType(struct SessionStopType* type, struct EXIService* service)
{
return 0;
}
static int serialize_SessionStopResType(struct SessionStopResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_ListOfRootCertificateIDsType(struct ListOfRootCertificateIDsType* type, struct EXIService* service)
{
size_t i_loop;
for(i_loop=0;i_loop < type->arraylen.RootCertificateID;i_loop++)
{
/* element ID assignment of RootCertificateID*/
service->eqn.namespaceURI=6;
service->eqn.localPart=108;
/* encode start element RootCertificateID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->RootCertificateID[i_loop].arraylen.data;
memcpy(service->val.string.codepoints, type->RootCertificateID[i_loop].data,type->RootCertificateID[i_loop].arraylen.data*sizeof(uint32_t));
/* encode character RootCertificateID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of RootCertificateID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_CertificateUpdateReqType(struct CertificateUpdateReqType* type, struct EXIService* service)
{
if(type->isused.attr_Id)
{
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
}
/* element ID assignment of ContractSignatureCertChain*/
service->eqn.namespaceURI=5;
service->eqn.localPart=31;
/* encode start element ContractSignatureCertChain */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ContractSignatureCertChain */
if(serialize_CertificateChainType( &(type->ContractSignatureCertChain),service))
{
return -1;
}
/* encode end element of ContractSignatureCertChain */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=30;
/* encode start element ContractID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->ContractID.arraylen.data;
memcpy(service->val.string.codepoints, type->ContractID.data,type->ContractID.arraylen.data*sizeof(uint32_t));
/* encode character ContractID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ContractID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ListOfRootCertificateIDs*/
service->eqn.namespaceURI=5;
service->eqn.localPart=59;
/* encode start element ListOfRootCertificateIDs */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ListOfRootCertificateIDs */
if(serialize_ListOfRootCertificateIDsType( &(type->ListOfRootCertificateIDs),service))
{
return -1;
}
/* encode end element of ListOfRootCertificateIDs */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_CertificateUpdateResType(struct CertificateUpdateResType* type, struct EXIService* service)
{
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractSignatureCertChain*/
service->eqn.namespaceURI=5;
service->eqn.localPart=31;
/* encode start element ContractSignatureCertChain */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ContractSignatureCertChain */
if(serialize_CertificateChainType( &(type->ContractSignatureCertChain),service))
{
return -1;
}
/* encode end element of ContractSignatureCertChain */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractSignatureEncryptedPrivateKey*/
service->eqn.namespaceURI=5;
service->eqn.localPart=32;
/* encode start element ContractSignatureEncryptedPrivateKey */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->ContractSignatureEncryptedPrivateKey.arraylen.data;
memcpy(service->val.binary.data, type->ContractSignatureEncryptedPrivateKey.data,type->ContractSignatureEncryptedPrivateKey.arraylen.data);
/* encode character ContractSignatureEncryptedPrivateKey */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ContractSignatureEncryptedPrivateKey */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractEncryptionEncryptedPrivateKey*/
service->eqn.namespaceURI=5;
service->eqn.localPart=29;
/* encode start element ContractEncryptionEncryptedPrivateKey */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->ContractEncryptionEncryptedPrivateKey.arraylen.data;
memcpy(service->val.binary.data, type->ContractEncryptionEncryptedPrivateKey.data,type->ContractEncryptionEncryptedPrivateKey.arraylen.data);
/* encode character ContractEncryptionEncryptedPrivateKey */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ContractEncryptionEncryptedPrivateKey */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of DHParams*/
service->eqn.namespaceURI=5;
service->eqn.localPart=39;
/* encode start element DHParams */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->DHParams.arraylen.data;
memcpy(service->val.binary.data, type->DHParams.data,type->DHParams.arraylen.data);
/* encode character DHParams */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of DHParams */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=30;
/* encode start element ContractID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->ContractID.arraylen.data;
memcpy(service->val.string.codepoints, type->ContractID.data,type->ContractID.arraylen.data*sizeof(uint32_t));
/* encode character ContractID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ContractID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of RetryCounter*/
service->eqn.namespaceURI=5;
service->eqn.localPart=84;
/* encode start element RetryCounter */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = INTEGER;
service->val.integer.val.int16=type->RetryCounter;
service->val.integer.type = INTEGER_16;
/* encode character RetryCounter */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of RetryCounter */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_CertificateInstallationReqType(struct CertificateInstallationReqType* type, struct EXIService* service)
{
if(type->isused.attr_Id)
{
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
}
/* element ID assignment of OEMProvisioningCert*/
service->eqn.namespaceURI=5;
service->eqn.localPart=65;
/* encode start element OEMProvisioningCert */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->OEMProvisioningCert.arraylen.data;
memcpy(service->val.binary.data, type->OEMProvisioningCert.data,type->OEMProvisioningCert.arraylen.data);
/* encode character OEMProvisioningCert */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of OEMProvisioningCert */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ListOfRootCertificateIDs*/
service->eqn.namespaceURI=5;
service->eqn.localPart=59;
/* encode start element ListOfRootCertificateIDs */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ListOfRootCertificateIDs */
if(serialize_ListOfRootCertificateIDsType( &(type->ListOfRootCertificateIDs),service))
{
return -1;
}
/* encode end element of ListOfRootCertificateIDs */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_CertificateInstallationResType(struct CertificateInstallationResType* type, struct EXIService* service)
{
/* element ID assignment of attr_Id*/
service->eqn.namespaceURI=0;
service->eqn.localPart=2;
service->val.type = STRING;
service->val.string.len = type->attr_Id.arraylen.data;
service->val.string.codepoints= type->attr_Id.data;
if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
{
return -1;
}
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractSignatureCertChain*/
service->eqn.namespaceURI=5;
service->eqn.localPart=31;
/* encode start element ContractSignatureCertChain */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ContractSignatureCertChain */
if(serialize_CertificateChainType( &(type->ContractSignatureCertChain),service))
{
return -1;
}
/* encode end element of ContractSignatureCertChain */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractSignatureEncryptedPrivateKey*/
service->eqn.namespaceURI=5;
service->eqn.localPart=32;
/* encode start element ContractSignatureEncryptedPrivateKey */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->ContractSignatureEncryptedPrivateKey.arraylen.data;
memcpy(service->val.binary.data, type->ContractSignatureEncryptedPrivateKey.data,type->ContractSignatureEncryptedPrivateKey.arraylen.data);
/* encode character ContractSignatureEncryptedPrivateKey */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ContractSignatureEncryptedPrivateKey */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractEncryptionEncryptedPrivateKey*/
service->eqn.namespaceURI=5;
service->eqn.localPart=29;
/* encode start element ContractEncryptionEncryptedPrivateKey */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->ContractEncryptionEncryptedPrivateKey.arraylen.data;
memcpy(service->val.binary.data, type->ContractEncryptionEncryptedPrivateKey.data,type->ContractEncryptionEncryptedPrivateKey.arraylen.data);
/* encode character ContractEncryptionEncryptedPrivateKey */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ContractEncryptionEncryptedPrivateKey */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of DHParams*/
service->eqn.namespaceURI=5;
service->eqn.localPart=39;
/* encode start element DHParams */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BINARY_BASE64;
service->val.binary.len = type->DHParams.arraylen.data;
memcpy(service->val.binary.data, type->DHParams.data,type->DHParams.arraylen.data);
/* encode character DHParams */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of DHParams */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of ContractID*/
service->eqn.namespaceURI=5;
service->eqn.localPart=30;
/* encode start element ContractID */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = STRING;
service->val.string.len = type->ContractID.arraylen.data;
memcpy(service->val.string.codepoints, type->ContractID.data,type->ContractID.arraylen.data*sizeof(uint32_t));
/* encode character ContractID */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ContractID */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_CableCheckReqType(struct CableCheckReqType* type, struct EXIService* service)
{
/* element ID assignment of DC_EVStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=38;
/* encode start element DC_EVStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVStatus */
if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
{
return -1;
}
/* encode end element of DC_EVStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_CableCheckResType(struct CableCheckResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of DC_EVSEStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=37;
/* encode start element DC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVSEStatus */
if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
{
return -1;
}
/* encode end element of DC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_PreChargeReqType(struct PreChargeReqType* type, struct EXIService* service)
{
/* element ID assignment of DC_EVStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=38;
/* encode start element DC_EVStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVStatus */
if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
{
return -1;
}
/* encode end element of DC_EVStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVTargetVoltage*/
service->eqn.namespaceURI=5;
service->eqn.localPart=57;
/* encode start element EVTargetVoltage */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVTargetVoltage */
if(serialize_PhysicalValueType( &(type->EVTargetVoltage),service))
{
return -1;
}
/* encode end element of EVTargetVoltage */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVTargetCurrent*/
service->eqn.namespaceURI=5;
service->eqn.localPart=56;
/* encode start element EVTargetCurrent */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVTargetCurrent */
if(serialize_PhysicalValueType( &(type->EVTargetCurrent),service))
{
return -1;
}
/* encode end element of EVTargetCurrent */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_PreChargeResType(struct PreChargeResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of DC_EVSEStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=37;
/* encode start element DC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVSEStatus */
if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
{
return -1;
}
/* encode end element of DC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEPresentVoltage*/
service->eqn.namespaceURI=5;
service->eqn.localPart=54;
/* encode start element EVSEPresentVoltage */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEPresentVoltage */
if(serialize_PhysicalValueType( &(type->EVSEPresentVoltage),service))
{
return -1;
}
/* encode end element of EVSEPresentVoltage */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_CurrentDemandReqType(struct CurrentDemandReqType* type, struct EXIService* service)
{
/* element ID assignment of DC_EVStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=38;
/* encode start element DC_EVStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVStatus */
if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
{
return -1;
}
/* encode end element of DC_EVStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVTargetCurrent*/
service->eqn.namespaceURI=5;
service->eqn.localPart=56;
/* encode start element EVTargetCurrent */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVTargetCurrent */
if(serialize_PhysicalValueType( &(type->EVTargetCurrent),service))
{
return -1;
}
/* encode end element of EVTargetCurrent */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVMaximumVoltageLimit)
{
/* element ID assignment of EVMaximumVoltageLimit*/
service->eqn.namespaceURI=5;
service->eqn.localPart=44;
/* encode start element EVMaximumVoltageLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMaximumVoltageLimit */
if(serialize_PhysicalValueType( &(type->EVMaximumVoltageLimit),service))
{
return -1;
}
/* encode end element of EVMaximumVoltageLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.EVMaximumCurrentLimit)
{
/* element ID assignment of EVMaximumCurrentLimit*/
service->eqn.namespaceURI=5;
service->eqn.localPart=42;
/* encode start element EVMaximumCurrentLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMaximumCurrentLimit */
if(serialize_PhysicalValueType( &(type->EVMaximumCurrentLimit),service))
{
return -1;
}
/* encode end element of EVMaximumCurrentLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.EVMaximumPowerLimit)
{
/* element ID assignment of EVMaximumPowerLimit*/
service->eqn.namespaceURI=5;
service->eqn.localPart=43;
/* encode start element EVMaximumPowerLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVMaximumPowerLimit */
if(serialize_PhysicalValueType( &(type->EVMaximumPowerLimit),service))
{
return -1;
}
/* encode end element of EVMaximumPowerLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.BulkChargingComplete)
{
/* element ID assignment of BulkChargingComplete*/
service->eqn.namespaceURI=5;
service->eqn.localPart=1;
/* encode start element BulkChargingComplete */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->BulkChargingComplete;
/* encode character BulkChargingComplete */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of BulkChargingComplete */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of ChargingComplete*/
service->eqn.namespaceURI=5;
service->eqn.localPart=19;
/* encode start element ChargingComplete */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->ChargingComplete;
/* encode character ChargingComplete */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ChargingComplete */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.RemainingTimeToFullSoC)
{
/* element ID assignment of RemainingTimeToFullSoC*/
service->eqn.namespaceURI=5;
service->eqn.localPart=82;
/* encode start element RemainingTimeToFullSoC */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of RemainingTimeToFullSoC */
if(serialize_PhysicalValueType( &(type->RemainingTimeToFullSoC),service))
{
return -1;
}
/* encode end element of RemainingTimeToFullSoC */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.RemainingTimeToBulkSoC)
{
/* element ID assignment of RemainingTimeToBulkSoC*/
service->eqn.namespaceURI=5;
service->eqn.localPart=81;
/* encode start element RemainingTimeToBulkSoC */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of RemainingTimeToBulkSoC */
if(serialize_PhysicalValueType( &(type->RemainingTimeToBulkSoC),service))
{
return -1;
}
/* encode end element of RemainingTimeToBulkSoC */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
/* element ID assignment of EVTargetVoltage*/
service->eqn.namespaceURI=5;
service->eqn.localPart=57;
/* encode start element EVTargetVoltage */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVTargetVoltage */
if(serialize_PhysicalValueType( &(type->EVTargetVoltage),service))
{
return -1;
}
/* encode end element of EVTargetVoltage */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_CurrentDemandResType(struct CurrentDemandResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of DC_EVSEStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=37;
/* encode start element DC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVSEStatus */
if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
{
return -1;
}
/* encode end element of DC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEPresentVoltage*/
service->eqn.namespaceURI=5;
service->eqn.localPart=54;
/* encode start element EVSEPresentVoltage */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEPresentVoltage */
if(serialize_PhysicalValueType( &(type->EVSEPresentVoltage),service))
{
return -1;
}
/* encode end element of EVSEPresentVoltage */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEPresentCurrent*/
service->eqn.namespaceURI=5;
service->eqn.localPart=53;
/* encode start element EVSEPresentCurrent */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEPresentCurrent */
if(serialize_PhysicalValueType( &(type->EVSEPresentCurrent),service))
{
return -1;
}
/* encode end element of EVSEPresentCurrent */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSECurrentLimitAchieved*/
service->eqn.namespaceURI=5;
service->eqn.localPart=46;
/* encode start element EVSECurrentLimitAchieved */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->EVSECurrentLimitAchieved;
/* encode character EVSECurrentLimitAchieved */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVSECurrentLimitAchieved */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEVoltageLimitAchieved*/
service->eqn.namespaceURI=5;
service->eqn.localPart=55;
/* encode start element EVSEVoltageLimitAchieved */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->EVSEVoltageLimitAchieved;
/* encode character EVSEVoltageLimitAchieved */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVSEVoltageLimitAchieved */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEPowerLimitAchieved*/
service->eqn.namespaceURI=5;
service->eqn.localPart=52;
/* encode start element EVSEPowerLimitAchieved */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = BOOLEAN;
service->val.boolean=type->EVSEPowerLimitAchieved;
/* encode character EVSEPowerLimitAchieved */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of EVSEPowerLimitAchieved */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
if(type->isused.EVSEMaximumVoltageLimit)
{
/* element ID assignment of EVSEMaximumVoltageLimit*/
service->eqn.namespaceURI=5;
service->eqn.localPart=51;
/* encode start element EVSEMaximumVoltageLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaximumVoltageLimit */
if(serialize_PhysicalValueType( &(type->EVSEMaximumVoltageLimit),service))
{
return -1;
}
/* encode end element of EVSEMaximumVoltageLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.EVSEMaximumCurrentLimit)
{
/* element ID assignment of EVSEMaximumCurrentLimit*/
service->eqn.namespaceURI=5;
service->eqn.localPart=49;
/* encode start element EVSEMaximumCurrentLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaximumCurrentLimit */
if(serialize_PhysicalValueType( &(type->EVSEMaximumCurrentLimit),service))
{
return -1;
}
/* encode end element of EVSEMaximumCurrentLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.EVSEMaximumPowerLimit)
{
/* element ID assignment of EVSEMaximumPowerLimit*/
service->eqn.namespaceURI=5;
service->eqn.localPart=50;
/* encode start element EVSEMaximumPowerLimit */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEMaximumPowerLimit */
if(serialize_PhysicalValueType( &(type->EVSEMaximumPowerLimit),service))
{
return -1;
}
/* encode end element of EVSEMaximumPowerLimit */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_WeldingDetectionReqType(struct WeldingDetectionReqType* type, struct EXIService* service)
{
/* element ID assignment of DC_EVStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=38;
/* encode start element DC_EVStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVStatus */
if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
{
return -1;
}
/* encode end element of DC_EVStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_WeldingDetectionResType(struct WeldingDetectionResType* type, struct EXIService* service)
{
/* element ID assignment of ResponseCode*/
service->eqn.namespaceURI=5;
service->eqn.localPart=83;
/* encode start element ResponseCode */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
service->val.type = ENUMERATION;
service->val.enumeration=type->ResponseCode;
/* encode character ResponseCode */
if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
{
return -1;
}
/* encode end element of ResponseCode */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of DC_EVSEStatus*/
service->eqn.namespaceURI=5;
service->eqn.localPart=37;
/* encode start element DC_EVSEStatus */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of DC_EVSEStatus */
if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
{
return -1;
}
/* encode end element of DC_EVSEStatus */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of EVSEPresentVoltage*/
service->eqn.namespaceURI=5;
service->eqn.localPart=54;
/* encode start element EVSEPresentVoltage */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of EVSEPresentVoltage */
if(serialize_PhysicalValueType( &(type->EVSEPresentVoltage),service))
{
return -1;
}
/* encode end element of EVSEPresentVoltage */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_BodyType(struct BodyType* type, struct EXIService* service)
{
if(type->isused.SessionSetupReq)
{
/* element ID assignment of SessionSetupReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=106;
/* encode start element SessionSetupReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SessionSetupReq */
if(serialize_SessionSetupReqType( (type->SessionSetupReq),service))
{
return -1;
}
/* encode end element of SessionSetupReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.SessionSetupRes)
{
/* element ID assignment of SessionSetupRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=108;
/* encode start element SessionSetupRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SessionSetupRes */
if(serialize_SessionSetupResType( (type->SessionSetupRes),service))
{
return -1;
}
/* encode end element of SessionSetupRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServiceDiscoveryReq)
{
/* element ID assignment of ServiceDiscoveryReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=93;
/* encode start element ServiceDiscoveryReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServiceDiscoveryReq */
if(serialize_ServiceDiscoveryReqType( (type->ServiceDiscoveryReq),service))
{
return -1;
}
/* encode end element of ServiceDiscoveryReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServiceDiscoveryRes)
{
/* element ID assignment of ServiceDiscoveryRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=95;
/* encode start element ServiceDiscoveryRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServiceDiscoveryRes */
if(serialize_ServiceDiscoveryResType( (type->ServiceDiscoveryRes),service))
{
return -1;
}
/* encode end element of ServiceDiscoveryRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServiceDetailReq)
{
/* element ID assignment of ServiceDetailReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=89;
/* encode start element ServiceDetailReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServiceDetailReq */
if(serialize_ServiceDetailReqType( (type->ServiceDetailReq),service))
{
return -1;
}
/* encode end element of ServiceDetailReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServiceDetailRes)
{
/* element ID assignment of ServiceDetailRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=91;
/* encode start element ServiceDetailRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServiceDetailRes */
if(serialize_ServiceDetailResType( (type->ServiceDetailRes),service))
{
return -1;
}
/* encode end element of ServiceDetailRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServicePaymentSelectionReq)
{
/* element ID assignment of ServicePaymentSelectionReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=100;
/* encode start element ServicePaymentSelectionReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServicePaymentSelectionReq */
if(serialize_ServicePaymentSelectionReqType( (type->ServicePaymentSelectionReq),service))
{
return -1;
}
/* encode end element of ServicePaymentSelectionReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ServicePaymentSelectionRes)
{
/* element ID assignment of ServicePaymentSelectionRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=102;
/* encode start element ServicePaymentSelectionRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ServicePaymentSelectionRes */
if(serialize_ServicePaymentSelectionResType( (type->ServicePaymentSelectionRes),service))
{
return -1;
}
/* encode end element of ServicePaymentSelectionRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.PaymentDetailsReq)
{
/* element ID assignment of PaymentDetailsReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=66;
/* encode start element PaymentDetailsReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PaymentDetailsReq */
if(serialize_PaymentDetailsReqType( (type->PaymentDetailsReq),service))
{
return -1;
}
/* encode end element of PaymentDetailsReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.PaymentDetailsRes)
{
/* element ID assignment of PaymentDetailsRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=68;
/* encode start element PaymentDetailsRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PaymentDetailsRes */
if(serialize_PaymentDetailsResType( (type->PaymentDetailsRes),service))
{
return -1;
}
/* encode end element of PaymentDetailsRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ContractAuthenticationReq)
{
/* element ID assignment of ContractAuthenticationReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=25;
/* encode start element ContractAuthenticationReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ContractAuthenticationReq */
if(serialize_ContractAuthenticationReqType( (type->ContractAuthenticationReq),service))
{
return -1;
}
/* encode end element of ContractAuthenticationReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ContractAuthenticationRes)
{
/* element ID assignment of ContractAuthenticationRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=27;
/* encode start element ContractAuthenticationRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ContractAuthenticationRes */
if(serialize_ContractAuthenticationResType( (type->ContractAuthenticationRes),service))
{
return -1;
}
/* encode end element of ContractAuthenticationRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ChargeParameterDiscoveryReq)
{
/* element ID assignment of ChargeParameterDiscoveryReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=14;
/* encode start element ChargeParameterDiscoveryReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ChargeParameterDiscoveryReq */
if(serialize_ChargeParameterDiscoveryReqType( (type->ChargeParameterDiscoveryReq),service))
{
return -1;
}
/* encode end element of ChargeParameterDiscoveryReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ChargeParameterDiscoveryRes)
{
/* element ID assignment of ChargeParameterDiscoveryRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=16;
/* encode start element ChargeParameterDiscoveryRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ChargeParameterDiscoveryRes */
if(serialize_ChargeParameterDiscoveryResType( (type->ChargeParameterDiscoveryRes),service))
{
return -1;
}
/* encode end element of ChargeParameterDiscoveryRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.PowerDeliveryReq)
{
/* element ID assignment of PowerDeliveryReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=71;
/* encode start element PowerDeliveryReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PowerDeliveryReq */
if(serialize_PowerDeliveryReqType( (type->PowerDeliveryReq),service))
{
return -1;
}
/* encode end element of PowerDeliveryReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.PowerDeliveryRes)
{
/* element ID assignment of PowerDeliveryRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=73;
/* encode start element PowerDeliveryRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PowerDeliveryRes */
if(serialize_PowerDeliveryResType( (type->PowerDeliveryRes),service))
{
return -1;
}
/* encode end element of PowerDeliveryRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ChargingStatusReq)
{
/* element ID assignment of ChargingStatusReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=21;
/* encode start element ChargingStatusReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ChargingStatusReq */
if(serialize_ChargingStatusReqType( (type->ChargingStatusReq),service))
{
return -1;
}
/* encode end element of ChargingStatusReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.ChargingStatusRes)
{
/* element ID assignment of ChargingStatusRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=23;
/* encode start element ChargingStatusRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of ChargingStatusRes */
if(serialize_ChargingStatusResType( (type->ChargingStatusRes),service))
{
return -1;
}
/* encode end element of ChargingStatusRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.MeteringReceiptReq)
{
/* element ID assignment of MeteringReceiptReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=61;
/* encode start element MeteringReceiptReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of MeteringReceiptReq */
if(serialize_MeteringReceiptReqType( (type->MeteringReceiptReq),service))
{
return -1;
}
/* encode end element of MeteringReceiptReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.MeteringReceiptRes)
{
/* element ID assignment of MeteringReceiptRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=63;
/* encode start element MeteringReceiptRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of MeteringReceiptRes */
if(serialize_MeteringReceiptResType( (type->MeteringReceiptRes),service))
{
return -1;
}
/* encode end element of MeteringReceiptRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.SessionStopReq)
{
/* element ID assignment of SessionStopReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=110;
/* encode start element SessionStopReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SessionStopReq */
if(serialize_SessionStopType( (type->SessionStopReq),service))
{
return -1;
}
/* encode end element of SessionStopReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.SessionStopRes)
{
/* element ID assignment of SessionStopRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=111;
/* encode start element SessionStopRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of SessionStopRes */
if(serialize_SessionStopResType( (type->SessionStopRes),service))
{
return -1;
}
/* encode end element of SessionStopRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.CertificateUpdateReq)
{
/* element ID assignment of CertificateUpdateReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=10;
/* encode start element CertificateUpdateReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CertificateUpdateReq */
if(serialize_CertificateUpdateReqType( (type->CertificateUpdateReq),service))
{
return -1;
}
/* encode end element of CertificateUpdateReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.CertificateUpdateRes)
{
/* element ID assignment of CertificateUpdateRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=12;
/* encode start element CertificateUpdateRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CertificateUpdateRes */
if(serialize_CertificateUpdateResType( (type->CertificateUpdateRes),service))
{
return -1;
}
/* encode end element of CertificateUpdateRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.CertificateInstallationReq)
{
/* element ID assignment of CertificateInstallationReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=6;
/* encode start element CertificateInstallationReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CertificateInstallationReq */
if(serialize_CertificateInstallationReqType( (type->CertificateInstallationReq),service))
{
return -1;
}
/* encode end element of CertificateInstallationReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.CertificateInstallationRes)
{
/* element ID assignment of CertificateInstallationRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=8;
/* encode start element CertificateInstallationRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CertificateInstallationRes */
if(serialize_CertificateInstallationResType( (type->CertificateInstallationRes),service))
{
return -1;
}
/* encode end element of CertificateInstallationRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.CableCheckReq)
{
/* element ID assignment of CableCheckReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=2;
/* encode start element CableCheckReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CableCheckReq */
if(serialize_CableCheckReqType( (type->CableCheckReq),service))
{
return -1;
}
/* encode end element of CableCheckReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.CableCheckRes)
{
/* element ID assignment of CableCheckRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=4;
/* encode start element CableCheckRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CableCheckRes */
if(serialize_CableCheckResType( (type->CableCheckRes),service))
{
return -1;
}
/* encode end element of CableCheckRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.PreChargeReq)
{
/* element ID assignment of PreChargeReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=75;
/* encode start element PreChargeReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PreChargeReq */
if(serialize_PreChargeReqType( (type->PreChargeReq),service))
{
return -1;
}
/* encode end element of PreChargeReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.PreChargeRes)
{
/* element ID assignment of PreChargeRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=77;
/* encode start element PreChargeRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of PreChargeRes */
if(serialize_PreChargeResType( (type->PreChargeRes),service))
{
return -1;
}
/* encode end element of PreChargeRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.CurrentDemandReq)
{
/* element ID assignment of CurrentDemandReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=33;
/* encode start element CurrentDemandReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CurrentDemandReq */
if(serialize_CurrentDemandReqType( (type->CurrentDemandReq),service))
{
return -1;
}
/* encode end element of CurrentDemandReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.CurrentDemandRes)
{
/* element ID assignment of CurrentDemandRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=35;
/* encode start element CurrentDemandRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of CurrentDemandRes */
if(serialize_CurrentDemandResType( (type->CurrentDemandRes),service))
{
return -1;
}
/* encode end element of CurrentDemandRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.WeldingDetectionReq)
{
/* element ID assignment of WeldingDetectionReq*/
service->eqn.namespaceURI=5;
service->eqn.localPart=114;
/* encode start element WeldingDetectionReq */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of WeldingDetectionReq */
if(serialize_WeldingDetectionReqType( (type->WeldingDetectionReq),service))
{
return -1;
}
/* encode end element of WeldingDetectionReq */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
if(type->isused.WeldingDetectionRes)
{
/* element ID assignment of WeldingDetectionRes*/
service->eqn.namespaceURI=5;
service->eqn.localPart=116;
/* encode start element WeldingDetectionRes */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of WeldingDetectionRes */
if(serialize_WeldingDetectionResType( (type->WeldingDetectionRes),service))
{
return -1;
}
/* encode end element of WeldingDetectionRes */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
}
return 0;
}
static int serialize_AnonType_V2G_Message(struct AnonType_V2G_Message* type, struct EXIService* service)
{
/* element ID assignment of Header*/
service->eqn.namespaceURI=7;
service->eqn.localPart=4;
/* encode start element Header */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of Header */
if(serialize_MessageHeaderType( (type->Header),service))
{
return -1;
}
/* encode end element of Header */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
/* element ID assignment of Body*/
service->eqn.namespaceURI=7;
service->eqn.localPart=0;
/* encode start element Body */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of Body */
if(serialize_BodyType( &(type->Body),service))
{
return -1;
}
/* encode end element of Body */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
static int serialize_EXIDocumentType(struct EXIDocumentType* type, struct EXIService* service)
{
/* element ID assignment of V2G_Message*/
service->eqn.namespaceURI=7;
service->eqn.localPart=5;
/* encode start element V2G_Message */
if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
{
return -1;
}
/* encode children of V2G_Message */
if(serialize_AnonType_V2G_Message( &(type->V2G_Message),service))
{
return -1;
}
/* encode end element of V2G_Message */
exiEncodeEndElement(&(service->outStream), &(service->stateEncode));
return 0;
}
/* marshal data to EXI stream */
static int serialize_message(struct EXIService* service)
{
/* encode start document */
if (exiEncodeStartDocument(&(service->outStream), &(service->stateEncode)) )
{
return -1;
}
/* encode root element of V2G_Message */
if (serialize_EXIDocumentType(&(service->exiMsg), service))
{
return -1;
}
/* encode end document */
if (exiEncodeEndDocument(&(service->outStream), &(service->stateEncode))) {
return -1;
}
return 0;
}