GF_Err gf_ipmpx_dump_DisconnectTool(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_DisconnectTool*p = (GF_IPMPX_DisconnectTool*)_p;
StartElement(trace, "IPMP_DisconnectTool", indent, XMTDump);
indent++;
DumpInt(trace, "IPMP_ToolContextID", p->IPMP_ToolContextID, indent, XMTDump);
EndAttributes(trace, XMTDump, 1);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_DisconnectTool", indent, XMTDump);
return GF_OK;
}
GF_Err gf_ipmpx_dump_GetToolsResponse(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_GetToolsResponse*p = (GF_IPMPX_GetToolsResponse*)_p;
StartElement(trace, "IPMP_GetToolsResponse", indent, XMTDump);
indent++;
EndAttributes(trace, XMTDump, 1);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
DumpDescList(p->ipmp_tools, trace, indent, "IPMP_Tools", XMTDump, 0);
indent--;
EndElement(trace, "IPMP_GetToolsResponse", indent, XMTDump);
return GF_OK;
}
GF_Err gf_ipmpx_dump_ToolParamCapabilitiesResponse(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_ToolParamCapabilitiesResponse*p = (GF_IPMPX_ToolParamCapabilitiesResponse*)_p;
StartElement(trace, "IPMP_ToolParamCapabilitiesResponse", indent, XMTDump);
indent++;
DumpBool(trace, "capabilitiesSupported", p->capabilitiesSupported, indent, XMTDump);
EndAttributes(trace, XMTDump, 1);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_ToolParamCapabilitiesResponse", indent, XMTDump);
return GF_OK;
}
GF_Err gf_ipmpx_dump_GetToolContext(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_GetToolContext*p = (GF_IPMPX_GetToolContext*)_p;
StartElement(trace, "IPMP_GetToolContext", indent, XMTDump);
indent++;
DumpInt(trace, "scope", p->scope, indent, XMTDump);
DumpInt(trace, "IPMP_DescriptorIDEx", p->IPMP_DescriptorIDEx, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_GetToolContext", indent, XMTDump);
return GF_OK;
}
GF_Err gf_ipmpx_dump_InitAuthentication(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_InitAuthentication*p = (GF_IPMPX_InitAuthentication*)_p;
StartElement(trace, "IPMP_InitAuthentication", indent, XMTDump);
indent++;
DumpInt(trace, "Context", p->Context, indent, XMTDump);
DumpInt(trace, "AuthType", p->AuthType, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_InitAuthentication", indent, XMTDump);
return GF_OK;
}
NxDeviceOscOutputMessage& NxDeviceOscOutputMessage::operator<<( const NxDeviceOscBundleTerminator& rhs )
{
(void) rhs;
if( !IsBundleInProgress() )
throw BundleNotInProgressException();
if( IsMessageInProgress() )
throw MessageInProgressException();
EndElement( messageCursor_ );
return *this;
}
GF_Err gf_ipmpx_dump_OpaqueData(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_OpaqueData *p = (GF_IPMPX_OpaqueData *)_p;
StartElement(trace, (p->tag==GF_IPMPX_RIGHTS_DATA_TAG) ? "IPMP_RightsData" : "IPMP_OpaqueData", indent, XMTDump);
indent++;
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
gf_ipmpx_dump_ByteArray(p->opaqueData, (p->tag==GF_IPMPX_RIGHTS_DATA_TAG) ? "rightsInfo" : "opaqueData", trace, indent, XMTDump);
indent--;
EndElement(trace, (p->tag==GF_IPMPX_RIGHTS_DATA_TAG) ? "IPMP_RightsData" : "IPMP_OpaqueData", indent, XMTDump);
return GF_OK;
}
OutboundPacketStream& OutboundPacketStream::operator<<( const BundleTerminator& rhs )
{
(void) rhs;
if( !IsBundleInProgress() )
throw BundleNotInProgressException();
if( IsMessageInProgress() )
throw MessageInProgressException();
EndElement( messageCursor_ );
return *this;
}
OutboundPacketStream& OutboundPacketStream::operator<<( const MessageTerminator& rhs )
{
(void) rhs;
if( !IsMessageInProgress() )
throw MessageNotInProgressException();
int typeTagsCount = end_ - typeTagsCurrent_;
if( typeTagsCount ){
char *tempTypeTags = (char*)alloca(typeTagsCount);
memcpy( tempTypeTags, typeTagsCurrent_, typeTagsCount );
// slot size includes comma and null terminator
int typeTagSlotSize = RoundUp4( typeTagsCount + 2 );
uint32 argumentsSize = argumentCurrent_ - messageCursor_;
memmove( messageCursor_ + typeTagSlotSize, messageCursor_, argumentsSize );
messageCursor_[0] = ',';
// copy type tags in reverse (really forward) order
for( int i=0; i < typeTagsCount; ++i )
messageCursor_[i+1] = tempTypeTags[ (typeTagsCount-1) - i ];
char *p = messageCursor_ + 1 + typeTagsCount;
for( int i=0; i < (typeTagSlotSize - (typeTagsCount + 1)); ++i )
*p++ = '\0';
typeTagsCurrent_ = end_;
// advance messageCursor_ for next message
messageCursor_ += typeTagSlotSize + argumentsSize;
}else{
// send an empty type tags string
memcpy( messageCursor_, ",\0\0\0", 4 );
// advance messageCursor_ for next message
messageCursor_ += 4;
}
argumentCurrent_ = messageCursor_;
EndElement( messageCursor_ );
messageIsInProgress_ = false;
return *this;
}
void CXmlBufExternalizerImpl::Field(const TDesC& aName, TBasicType, const TDesC& aValue,
TBool aIncludeBBType, const TTypeName& aBBType,
TBool aAsAttribute)
{
if (! aAsAttribute ) {
BeginElement(aName, aIncludeBBType, aBBType);
if (iInOpenElement) { iInOpenElement=EFalse; CloseOpenElement(); }
CXmlBuf::Characters(aValue);
EndElement(aName);
} else {
if (aIncludeBBType) User::Leave(KErrGeneral);
Attribute(aName, aValue);
}
}
void SQDbgServer::Break(int line,const SQChar *src,const SQChar *type,const SQChar *error)
{
if(!error){
BeginDocument();
BeginElement(_SC("break"));
Attribute(_SC("line"),IntToString(line));
Attribute(_SC("src"),src);
Attribute(_SC("type"),type);
SerializeState();
EndElement(_SC("break"));
EndDocument();
}else{
BeginDocument();
BeginElement(_SC("break"));
Attribute(_SC("line"),IntToString(line));
Attribute(_SC("src"),src);
Attribute(_SC("type"),type);
Attribute(_SC("error"),error);
SerializeState();
EndElement(_SC("break"));
EndDocument();
}
}
GF_Err gf_ipmpx_dump_GetToolContextResponse(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_GetToolContextResponse*p = (GF_IPMPX_GetToolContextResponse*)_p;
StartElement(trace, "IPMP_GetToolContextResponse", indent, XMTDump);
indent++;
DumpInt(trace, "OD_ID", p->OD_ID, indent, XMTDump);
DumpInt(trace, "ESD_ID", p->ESD_ID, indent, XMTDump);
DumpInt(trace, "IPMP_ToolContextID", p->IPMP_ToolContextID, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_GetToolContextResponse", indent, XMTDump);
return GF_OK;
}
void EndDocument()
{
#if _DEBUG
if(!m_stack.empty())
{
TRACE(_T("warning: タグが閉じられないまま XMLWriter.EndDocument() されました"));
}
#endif
while(!m_stack.empty())
{
EndElement();
}
m_stream.clear();
}
GF_Err gf_ipmpx_dump_ToolAPI_Config(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_ToolAPI_Config*p = (GF_IPMPX_ToolAPI_Config*)_p;
StartElement(trace, "IPMP_ToolAPI_Config", indent, XMTDump);
indent++;
DumpInt(trace, "Instantiation_API_ID", p->Instantiation_API_ID, indent, XMTDump);
DumpInt(trace, "Messaging_API_ID", p->Messaging_API_ID, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
gf_ipmpx_dump_ByteArray(p->opaqueData, "opaqueData", trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_ToolAPI_Config", indent, XMTDump);
return GF_OK;
}
GF_Err gf_ipmpx_dump_ISMACryp(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_ISMACryp*p = (GF_IPMPX_ISMACryp*)_p;
StartElement(trace, "ISMACryp_Data", indent, XMTDump);
indent++;
DumpInt(trace, "crypto_suite", p->cryptoSuite, indent, XMTDump);
DumpInt(trace, "IV_length", p->IV_length, indent, XMTDump);
DumpBool(trace, "selective_encryption", p->use_selective_encryption, indent, XMTDump);
DumpInt(trace, "key_indicator_length", p->key_indicator_length, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, "ISMACryp_Data", indent, XMTDump);
return GF_OK;
}
GF_Err gf_ipmpx_dump_SecureContainer(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_SecureContainer*p = (GF_IPMPX_SecureContainer*)_p;
StartElement(trace, "IPMP_SecureContainer", indent, XMTDump);
indent++;
DumpBool(trace, "isMACEncrypted", p->isMACEncrypted, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
if (p->encryptedData) gf_ipmpx_dump_ByteArray(p->encryptedData, "encryptedData", trace, indent, XMTDump);
if (p->protectedMsg) gf_ipmpx_dump_data(p->protectedMsg, trace, indent, XMTDump);
if (p->MAC) gf_ipmpx_dump_ByteArray(p->MAC, "MAC", trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_SecureContainer", indent, XMTDump);
return GF_OK;
}
GF_Err gf_ipmpx_dump_SendWatermark(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_SendWatermark*p = (GF_IPMPX_SendWatermark*)_p;
StartElement(trace, (char*) ((_p->tag==GF_IPMPX_AUDIO_WM_SEND_TAG) ? "IPMP_SendAudioWatermark" : "IPMP_SendVideoWatermark"), indent, XMTDump);
indent++;
DumpInt(trace, "wmStatus", p->wm_status, indent, XMTDump);
DumpInt(trace, "compression_status", p->compression_status, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
if (p->wm_status==GF_IPMPX_WM_PAYLOAD) gf_ipmpx_dump_ByteArray(p->payload, "payload", trace, indent, XMTDump);
if (p->opaqueData) gf_ipmpx_dump_ByteArray(p->opaqueData, "opaqueData", trace, indent, XMTDump);
indent--;
EndElement(trace, (char*) ( (_p->tag==GF_IPMPX_AUDIO_WM_SEND_TAG) ? "IPMP_SendAudioWatermark" : "IPMP_SendVideoWatermark"), indent, XMTDump);
return GF_OK;
}
void SQDbgServer::RemoveWatch(int id)
{
WatchSetItor itor=_watches.find(Watch(id,_SC("")));
if(itor==_watches.end()){
BeginDocument();
BeginElement(_SC("error"));
Attribute(_SC("desc"),_SC("the watch does not exists"));
EndElement(_SC("error"));
EndDocument();
}
else{
_watches.erase(itor);
scprintf(_SC("removed watch %d\n"),id);
}
}
GF_Err gf_ipmpx_dump_NotifyToolEvent(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_NotifyToolEvent*p = (GF_IPMPX_NotifyToolEvent*)_p;
StartElement(trace, "IPMP_NotifyToolEvent", indent, XMTDump);
indent++;
DumpInt(trace, "OD_ID", p->OD_ID, indent, XMTDump);
DumpInt(trace, "ESD_ID", p->ESD_ID, indent, XMTDump);
DumpInt(trace, "IPMP_ToolContextID", p->IPMP_ToolContextID, indent, XMTDump);
DumpInt(trace, "eventType", p->eventType, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_NotifyToolEvent", indent, XMTDump);
return GF_OK;
}
GF_Err gf_ipmpx_dump_WatermarkingInit(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_WatermarkingInit*p = (GF_IPMPX_WatermarkingInit*)_p;
StartElement(trace, (char*) ( (_p->tag==GF_IPMPX_AUDIO_WM_INIT_TAG) ? "IPMP_AudioWatermarkingInit" : "IPMP_VideoWatermarkingInit"), indent, XMTDump);
indent++;
DumpInt(trace, "inputFormat", p->inputFormat, indent, XMTDump);
DumpInt(trace, "requiredOp", p->requiredOp, indent, XMTDump);
if (p->inputFormat==0x01) {
if (_p->tag==GF_IPMPX_AUDIO_WM_INIT_TAG) {
DumpInt(trace, "nChannels", p->nChannels, indent, XMTDump);
DumpInt(trace, "bitPerSample", p->bitPerSample, indent, XMTDump);
DumpInt(trace, "frequency", p->frequency, indent, XMTDump);
} else {
DumpInt(trace, "frame_horizontal_size", p->frame_horizontal_size, indent, XMTDump);
DumpInt(trace, "frame_vertical_size", p->frame_vertical_size, indent, XMTDump);
DumpInt(trace, "chroma_format", p->chroma_format, indent, XMTDump);
}
}
switch (p->requiredOp) {
case GF_IPMPX_WM_INSERT:
case GF_IPMPX_WM_REMARK:
DumpData(trace, "wmPayload", p->wmPayload, p->wmPayloadLen, indent, XMTDump);
break;
case GF_IPMPX_WM_EXTRACT:
case GF_IPMPX_WM_DETECT_COMPRESSION:
DumpInt(trace, "wmRecipientId", p->wmRecipientId, indent, XMTDump);
break;
}
if (p->opaqueData) DumpData(trace, "opaqueData", p->opaqueData, p->opaqueDataSize, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, (char*) ( (_p->tag==GF_IPMPX_AUDIO_WM_INIT_TAG) ? "IPMP_AudioWatermarkingInit" : "IPMP_VideoWatermarkingInit"), indent, XMTDump);
return GF_OK;
}
void XmlWriter::WriteNode(const std::string& name, const T& val) {
BeginElement(name);
Write<T>(val);
EndElement(name);
}
static int EndElementN(void *u, const XMLCH *i, const XMLCH *l, const XMLCH *n)
{ return EndElement(R3AD3R,i,l,n); }
GF_Err gf_ipmpx_dump_MutualAuthentication(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
u32 i, count;
GF_IPMPX_MutualAuthentication *p = (GF_IPMPX_MutualAuthentication*)_p;
StartElement(trace, "IPMP_MutualAuthentication", indent, XMTDump);
indent++;
DumpBool(trace, "failedNegotiation", p->failedNegotiation, indent, XMTDump);
if (gf_list_count(p->certificates)) DumpInt(trace, "certType", p->certType, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
StartList(trace, "candidateAlgorithms", indent, XMTDump);
count = gf_list_count(p->candidateAlgorithms);
indent++;
for (i=0; i<count; i++) {
GF_IPMPX_Authentication *ip_auth = (GF_IPMPX_Authentication *)gf_list_get(p->candidateAlgorithms, i);
gf_ipmpx_dump_AUTH(ip_auth, trace, indent, XMTDump);
}
indent--;
EndList(trace, "candidateAlgorithms", indent, XMTDump);
StartList(trace, "agreedAlgorithms", indent, XMTDump);
count = gf_list_count(p->agreedAlgorithms);
indent++;
for (i=0; i<count; i++) {
GF_IPMPX_Authentication *ip_auth = (GF_IPMPX_Authentication *)gf_list_get(p->agreedAlgorithms, i);
gf_ipmpx_dump_AUTH(ip_auth, trace, indent, XMTDump);
}
indent--;
EndList(trace, "agreedAlgorithms", indent, XMTDump);
if (p->AuthenticationData) gf_ipmpx_dump_ByteArray(p->AuthenticationData, "AuthenticationData", trace, indent, XMTDump);
count = gf_list_count(p->certificates);
if (count || p->opaque || p->publicKey) {
/*type 1*/
if (count) {
StartList(trace, "certificates", indent, XMTDump);
for (i=0; i<count; i++) {
GF_IPMPX_ByteArray *ipd = (GF_IPMPX_ByteArray *)gf_list_get(p->certificates, i);
if (XMTDump) {
gf_ipmpx_dump_ByteArray(ipd, NULL, trace, indent, XMTDump);
} else {
StartAttribute(trace, "", indent, GF_FALSE);
DumpData(trace, NULL, ipd->data, ipd->length, indent, GF_FALSE);
if (i+1<count) fprintf(trace, ",");
fprintf(trace, "\n");
}
}
EndList(trace, "certificates", indent, XMTDump);
}
/*type 2*/
else if (p->publicKey) {
gf_ipmpx_dump_AUTH((GF_IPMPX_Authentication *) p->publicKey, trace, indent, XMTDump);
}
/*type 0xFE*/
else if (p->opaque) {
gf_ipmpx_dump_ByteArray(p->opaque, "opaque", trace, indent, XMTDump);
}
if (!XMTDump) StartAttribute(trace, "trustData", indent, GF_FALSE);
else {
StartElement(trace, "trustData", indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
}
gf_ipmpx_dump_data((GF_IPMPX_Data *)p->trustData, trace, indent, XMTDump);
if (XMTDump) EndElement(trace, "trustData", indent, XMTDump);
gf_ipmpx_dump_ByteArray(p->authCodes, "authCodes", trace, indent, XMTDump);
}
indent--;
EndElement(trace, "IPMP_MutualAuthentication", indent, XMTDump);
return GF_OK;
}
void XmlWriter::WriteBooleanElement(const string &elementName, bool elementValue)
{
StartElement(elementName);
stringStream << (elementValue ? "true" : "false");
EndElement();
}
GF_Err gf_ipmpx_dump_SelectiveDecryptionInit(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
u32 i, count;
GF_IPMPX_SelectiveDecryptionInit*p = (GF_IPMPX_SelectiveDecryptionInit*)_p;
StartElement(trace, "IPMP_SelectiveDecryptionInit", indent, XMTDump);
indent++;
DumpInt(trace, "mediaTypeExtension", p->mediaTypeExtension, indent, XMTDump);
DumpInt(trace, "mediaTypeIndication", p->mediaTypeIndication, indent, XMTDump);
DumpInt(trace, "profileLevelIndication", p->profileLevelIndication, indent, XMTDump);
DumpInt(trace, "compliance", p->compliance, indent, XMTDump);
if (p->RLE_Data) DumpData_16(trace, "RLE_Data", p->RLE_Data, p->RLE_DataLength, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
count = gf_list_count(p->SelEncBuffer);
if (count) {
StartList(trace, "SelectiveBuffers", indent, XMTDump);
indent++;
for (i=0; i<count; i++) {
GF_IPMPX_SelEncBuffer *sb = (GF_IPMPX_SelEncBuffer *)gf_list_get(p->SelEncBuffer, i);
StartElement(trace, "IPMP_SelectiveBuffer", indent, XMTDump);
indent++;
DumpBin128(trace, "cipher_Id", (char*)sb->cipher_Id, indent, XMTDump);
DumpInt(trace, "syncBoundary", sb->syncBoundary, indent, XMTDump);
if (!sb->Stream_Cipher_Specific_Init_Info) {
DumpInt(trace, "mode", sb->mode, indent, XMTDump);
DumpInt(trace, "blockSize", sb->blockSize, indent, XMTDump);
DumpInt(trace, "keySize", sb->keySize, indent, XMTDump);
}
EndAttributes(trace, XMTDump, GF_TRUE);
if (sb->Stream_Cipher_Specific_Init_Info)
gf_ipmpx_dump_ByteArray(sb->Stream_Cipher_Specific_Init_Info, "StreamCipher", trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_SelectiveBuffer", indent, XMTDump);
}
indent--;
EndList(trace, "SelectiveBuffers", indent, XMTDump);
}
count = gf_list_count(p->SelEncFields);
if (!p->RLE_Data && count) {
StartList(trace, "SelectiveFields", indent, XMTDump);
indent++;
for (i=0; i<count; i++) {
GF_IPMPX_SelEncField *sf = (GF_IPMPX_SelEncField *)gf_list_get(p->SelEncFields, i);
StartElement(trace, "IPMP_SelectiveField", indent, XMTDump);
indent++;
DumpInt(trace, "field_Id", sf->field_Id, indent, XMTDump);
DumpInt(trace, "field_Scope", sf->field_Scope, indent, XMTDump);
DumpInt(trace, "buf", sf->buf, indent, XMTDump);
if (sf->mappingTable) DumpData_16(trace, "mappingTable", sf->mappingTable, sf->mappingTableSize, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
if (sf->shuffleSpecificInfo)
gf_ipmpx_dump_ByteArray(sf->shuffleSpecificInfo, "shuffleSpecificInfo", trace, indent, XMTDump);
indent--;
EndElement(trace, "IPMP_SelectiveField", indent, XMTDump);
}
indent--;
EndList(trace, "SelectiveFields", indent, XMTDump);
}
indent--;
EndElement(trace, "IPMP_SelectiveDecryptionInit", indent, XMTDump);
return GF_OK;
}
void XmlWriter::WriteDoubleElement(const string &elementName, double elementValue)
{
StartElement(elementName);
stringStream << elementValue;
EndElement();
}
void XmlWriter::WriteIntElement(const string &elementName, int elementValue)
{
StartElement(elementName);
stringStream << elementValue;
EndElement();
}
void XmlWriter::WriteTextElement(const string &elementName, const string &elementValue)
{
StartElement(elementName);
stringStream << elementValue.c_str();
EndElement();
}
void WriteElement(T callback, Args... args) {
BeginElement();
callback(writer, args...);
EndElement();
}
void WriteElement(const char *name, T callback, Args... args) {
BeginElement(name);
callback(writer, args...);
EndElement();
}
