void PropertyXml::add( const SmartPtrCPropertyDoc propertyDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("PropertyXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(propertyDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string nameVal = propertyDoc->getName(); CAF_CM_VALIDATE_STRING(nameVal); thisXml->addAttribute("name", nameVal); const std::string typeVal = EnumConvertersXml::convertPropertyTypeToString(propertyDoc->getType()); CAF_CM_VALIDATE_STRING(typeVal); thisXml->addAttribute("type", typeVal); const std::deque<std::string> valueVal = propertyDoc->getValue(); CAF_CM_VALIDATE_STL(valueVal); if (! valueVal.empty()) { for (TConstIterator<std::deque<std::string> > valueIter(valueVal); valueIter; valueIter++) { const SmartPtrCXmlElement valueXml = thisXml->createAndAddElement("value"); valueXml->setValue(*valueIter); } } } CAF_CM_EXIT; }
void ClassFieldXml::add( const SmartPtrCClassFieldDoc classFieldDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ClassFieldXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(classFieldDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string namespaceValVal = classFieldDoc->getNamespaceVal(); CAF_CM_VALIDATE_STRING(namespaceValVal); thisXml->addAttribute("namespace", namespaceValVal); const std::string nameVal = classFieldDoc->getName(); CAF_CM_VALIDATE_STRING(nameVal); thisXml->addAttribute("name", nameVal); const std::string versionVal = classFieldDoc->getVersion(); CAF_CM_VALIDATE_STRING(versionVal); thisXml->addAttribute("version", versionVal); const std::string fieldVal = classFieldDoc->getField(); CAF_CM_VALIDATE_STRING(fieldVal); thisXml->addAttribute("field", fieldVal); } CAF_CM_EXIT; }
void ResponseHeaderXml::add( const SmartPtrCResponseHeaderDoc responseHeaderDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ResponseHeaderXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(responseHeaderDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string versionVal = responseHeaderDoc->getVersion(); CAF_CM_VALIDATE_STRING(versionVal); thisXml->addAttribute("version", versionVal); const std::string createdDateTimeVal = responseHeaderDoc->getCreatedDateTime(); CAF_CM_VALIDATE_STRING(createdDateTimeVal); thisXml->addAttribute("createdDateTime", createdDateTimeVal); const std::string sequenceNumberVal = CStringConv::toString<uint32>(responseHeaderDoc->getSequenceNumber()); CAF_CM_VALIDATE_STRING(sequenceNumberVal); thisXml->addAttribute("sequenceNumber", sequenceNumberVal); const std::string isFinalResponseVal = responseHeaderDoc->getIsFinalResponse() ? "true" : "false"; CAF_CM_VALIDATE_STRING(isFinalResponseVal); thisXml->addAttribute("isFinalResponse", isFinalResponseVal); const std::string sessionIdVal = BasePlatform::UuidToString(responseHeaderDoc->getSessionId()); if (! sessionIdVal.empty()) { thisXml->addAttribute("sessionId", sessionIdVal); } } CAF_CM_EXIT; }
SmartPtrCAttachmentNameCollectionDoc AttachmentNameCollectionXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("AttachmentNameCollectionXml", "parse"); SmartPtrCAttachmentNameCollectionDoc attachmentNameCollectionDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const CXmlElement::SmartPtrCElementCollection nameChildrenXml = thisXml->findRequiredChildren("attachmentName"); std::deque<std::string> nameVal; if (! nameChildrenXml.IsNull() && ! nameChildrenXml->empty()) { for (TConstIterator<CXmlElement::CElementCollection> nameXmlIter(*nameChildrenXml); nameXmlIter; nameXmlIter++) { const SmartPtrCXmlElement nameXml = nameXmlIter->second; const std::string name = nameXml->findRequiredAttribute("name"); nameVal.push_back(name); } } attachmentNameCollectionDoc.CreateInstance(); attachmentNameCollectionDoc->initialize( nameVal); } CAF_CM_EXIT; return attachmentNameCollectionDoc; }
SmartPtrCCmdlUnionDoc CmdlUnionXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("CmdlUnionXml", "parse"); SmartPtrCCmdlUnionDoc cmdlUnionDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string namespaceValStrVal = thisXml->findRequiredAttribute("namespace"); const std::string namespaceValVal = namespaceValStrVal; const std::string nameStrVal = thisXml->findRequiredAttribute("name"); const std::string nameVal = nameStrVal; const std::string versionStrVal = thisXml->findRequiredAttribute("version"); const std::string versionVal = versionStrVal; cmdlUnionDoc.CreateInstance(); cmdlUnionDoc->initialize( namespaceValVal, nameVal, versionVal); } CAF_CM_EXIT; return cmdlUnionDoc; }
void ActionClassInstanceXml::add( const SmartPtrCActionClassInstanceDoc actionClassInstanceDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ActionClassInstanceXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(actionClassInstanceDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string namespaceValVal = actionClassInstanceDoc->getNamespaceVal(); CAF_CM_VALIDATE_STRING(namespaceValVal); thisXml->addAttribute("namespace", namespaceValVal); const std::string nameVal = actionClassInstanceDoc->getName(); CAF_CM_VALIDATE_STRING(nameVal); thisXml->addAttribute("name", nameVal); const std::string versionVal = actionClassInstanceDoc->getVersion(); CAF_CM_VALIDATE_STRING(versionVal); thisXml->addAttribute("version", versionVal); const SmartPtrCInstanceOperationCollectionDoc instanceOperationCollectionVal = actionClassInstanceDoc->getInstanceOperationCollection(); CAF_CM_VALIDATE_SMARTPTR(instanceOperationCollectionVal); const SmartPtrCXmlElement instanceOperationCollectionXml = thisXml->createAndAddElement("instanceOperationCollection"); InstanceOperationCollectionXml::add(instanceOperationCollectionVal, instanceOperationCollectionXml); } CAF_CM_EXIT; }
SmartPtrCXmlElement CConfigProvider::findXmlElement( const std::deque<std::string>& keyPathCollection, const SmartPtrCXmlElement& rootXml) const { CAF_CM_FUNCNAME("findXmlElement"); SmartPtrCXmlElement xmlRc; CAF_CM_ENTER { CAF_CM_VALIDATE_STL(keyPathCollection); CAF_CM_VALIDATE_SMARTPTR(rootXml); xmlRc = rootXml; for (std::deque<std::string>::const_iterator keyPathIter = keyPathCollection.begin(); keyPathIter != keyPathCollection.end(); keyPathIter++) { const std::string keyPath = *keyPathIter; if (keyPathIter == keyPathCollection.begin()) { if (xmlRc->getName().compare(keyPath) != 0) { CAF_CM_EXCEPTIONEX_VA2(NoSuchElementException, ERROR_NOT_FOUND, "Root element does not match - %s != %s", keyPath.c_str(), xmlRc->getName().c_str()); } } else { xmlRc = xmlRc->findRequiredChild(keyPath); } } } CAF_CM_EXIT; return xmlRc; }
SmartPtrCLoggingLevelElemDoc LoggingLevelElemXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("LoggingLevelElemXml", "parse"); SmartPtrCLoggingLevelElemDoc loggingLevelElemDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string componentStrVal = thisXml->findRequiredAttribute("component"); LOGGINGCOMPONENT_TYPE componentVal = LOGGINGCOMPONENT_NONE; if (! componentStrVal.empty()) { componentVal = EnumConvertersXml::convertStringToLoggingComponentType(componentStrVal); } const std::string levelStrVal = thisXml->findRequiredAttribute("level"); LOGGINGLEVEL_TYPE levelVal = LOGGINGLEVEL_NONE; if (! levelStrVal.empty()) { levelVal = EnumConvertersXml::convertStringToLoggingLevelType(levelStrVal); } loggingLevelElemDoc.CreateInstance(); loggingLevelElemDoc->initialize( componentVal, levelVal); } CAF_CM_EXIT; return loggingLevelElemDoc; }
SmartPtrCEventKeyDoc EventKeyXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("EventKeyXml", "parse"); SmartPtrCEventKeyDoc eventKeyDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string nameStrVal = thisXml->findRequiredAttribute("name"); const std::string nameVal = nameStrVal; const std::string valueStrVal = thisXml->findRequiredAttribute("value"); const std::string valueVal = valueStrVal; eventKeyDoc.CreateInstance(); eventKeyDoc->initialize( nameVal, valueVal); } CAF_CM_EXIT; return eventKeyDoc; }
SmartPtrCCmdlMetadataDoc CmdlMetadataXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("CmdlMetadataXml", "parse"); SmartPtrCCmdlMetadataDoc cmdlMetadataDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string nameStrVal = thisXml->findRequiredAttribute("name"); const std::string nameVal = nameStrVal; const SmartPtrCXmlElement valueXml = thisXml->findRequiredChild("value"); std::string valueVal; if (! valueXml.IsNull()) { valueVal = valueXml->getValue(); } cmdlMetadataDoc.CreateInstance(); cmdlMetadataDoc->initialize( nameVal, valueVal); } CAF_CM_EXIT; return cmdlMetadataDoc; }
void DiagDeleteValueXml::add( const SmartPtrCDiagDeleteValueDoc diagDeleteValueDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("DiagDeleteValueXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(diagDeleteValueDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string jobIdVal = BasePlatform::UuidToString(diagDeleteValueDoc->getJobId()); CAF_CM_VALIDATE_STRING(jobIdVal); thisXml->addAttribute("jobId", jobIdVal); const std::string fileAliasVal = diagDeleteValueDoc->getFileAlias(); CAF_CM_VALIDATE_STRING(fileAliasVal); thisXml->addAttribute("fileAlias", fileAliasVal); const std::string valueNameVal = diagDeleteValueDoc->getValueName(); CAF_CM_VALIDATE_STRING(valueNameVal); const SmartPtrCXmlElement valueNameXml = thisXml->createAndAddElement("valueName"); valueNameXml->setValue(valueNameVal); } CAF_CM_EXIT; }
SmartPtrCInstallProviderSpecDoc InstallProviderSpecXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("InstallProviderSpecXml", "parse"); SmartPtrCInstallProviderSpecDoc installProviderSpecDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string clientIdStrVal = thisXml->findRequiredAttribute("clientId"); UUID clientIdVal = CAFCOMMON_GUID_NULL; if (! clientIdStrVal.empty()) { BasePlatform::UuidFromString(clientIdStrVal.c_str(), clientIdVal); } const std::string providerNamespaceStrVal = thisXml->findRequiredAttribute("providerNamespace"); const std::string providerNamespaceVal = providerNamespaceStrVal; const std::string providerNameStrVal = thisXml->findRequiredAttribute("providerName"); const std::string providerNameVal = providerNameStrVal; const std::string providerVersionStrVal = thisXml->findRequiredAttribute("providerVersion"); const std::string providerVersionVal = providerVersionStrVal; const CXmlElement::SmartPtrCElementCollection packageValChildrenXml = thisXml->findRequiredChildren("package"); std::deque<SmartPtrCMinPackageElemDoc> packageValVal; if (! packageValChildrenXml.IsNull() && ! packageValChildrenXml->empty()) { for (TConstIterator<CXmlElement::CElementCollection> packageValXmlIter(*packageValChildrenXml); packageValXmlIter; packageValXmlIter++) { const SmartPtrCXmlElement packageValXml = packageValXmlIter->second; const SmartPtrCMinPackageElemDoc packageValDoc = MinPackageElemXml::parse(packageValXml); packageValVal.push_back(packageValDoc); } } installProviderSpecDoc.CreateInstance(); installProviderSpecDoc->initialize( clientIdVal, providerNamespaceVal, providerNameVal, providerVersionVal, packageValVal); } CAF_CM_EXIT; return installProviderSpecDoc; }
SmartPtrCErrorResponseDoc ErrorResponseXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ErrorResponseXml", "parse"); SmartPtrCErrorResponseDoc errorResponseDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string clientIdStrVal = thisXml->findOptionalAttribute("clientId"); UUID clientIdVal = CAFCOMMON_GUID_NULL; if (! clientIdStrVal.empty()) { BasePlatform::UuidFromString(clientIdStrVal.c_str(), clientIdVal); } const std::string requestIdStrVal = thisXml->findOptionalAttribute("requestId"); UUID requestIdVal = CAFCOMMON_GUID_NULL; if (! requestIdStrVal.empty()) { BasePlatform::UuidFromString(requestIdStrVal.c_str(), requestIdVal); } const std::string pmeIdVal = thisXml->findOptionalAttribute("pmeId"); const SmartPtrCXmlElement responseHeaderXml = thisXml->findOptionalChild("responseHeader"); SmartPtrCResponseHeaderDoc responseHeaderVal; if (! responseHeaderXml.IsNull()) { responseHeaderVal = ResponseHeaderXml::parse(responseHeaderXml); } const SmartPtrCXmlElement errorMessageXml = thisXml->findOptionalChild("errorMessage"); std::string errorMessageVal; if (! errorMessageXml.IsNull()) { errorMessageVal = errorMessageXml->getValue(); } errorResponseDoc.CreateInstance(); errorResponseDoc->initialize( clientIdVal, requestIdVal, pmeIdVal, responseHeaderVal, errorMessageVal); } CAF_CM_EXIT; return errorResponseDoc; }
std::string XmlRoots::savePersistenceToString( const SmartPtrCPersistenceDoc persistenceDoc) { CAF_CM_STATIC_FUNC_VALIDATE("XmlRoots", "savePersistenceToString"); CAF_CM_VALIDATE_SMARTPTR(persistenceDoc); const std::string schemaNamespace = DocXmlUtils::getSchemaNamespace("fx"); const std::string schemaLocation = DocXmlUtils::getSchemaLocation("fx/Persistence.xsd"); const SmartPtrCXmlElement rootXml = CXmlUtils::createRootElement( "persistence", schemaNamespace, schemaLocation); PersistenceXml::add(persistenceDoc, rootXml); return rootXml->saveToString(); }
SmartPtrCDiagRequestDoc DiagRequestXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("DiagRequestXml", "parse"); SmartPtrCDiagRequestDoc diagRequestDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string clientIdStrVal = thisXml->findRequiredAttribute("clientId"); UUID clientIdVal = CAFCOMMON_GUID_NULL; if (! clientIdStrVal.empty()) { BasePlatform::UuidFromString(clientIdStrVal.c_str(), clientIdVal); } const std::string requestIdStrVal = thisXml->findRequiredAttribute("requestId"); UUID requestIdVal = CAFCOMMON_GUID_NULL; if (! requestIdStrVal.empty()) { BasePlatform::UuidFromString(requestIdStrVal.c_str(), requestIdVal); } const std::string pmeIdVal = thisXml->findRequiredAttribute("pmeId"); const SmartPtrCXmlElement requestHeaderXml = thisXml->findRequiredChild("requestHeader"); SmartPtrCRequestHeaderDoc requestHeaderVal; if (! requestHeaderXml.IsNull()) { requestHeaderVal = RequestHeaderXml::parse(requestHeaderXml); } const SmartPtrCXmlElement batchXml = thisXml->findRequiredChild("batch"); SmartPtrCDiagBatchDoc batchVal; if (! batchXml.IsNull()) { batchVal = DiagBatchXml::parse(batchXml); } diagRequestDoc.CreateInstance(); diagRequestDoc->initialize( clientIdVal, requestIdVal, pmeIdVal, requestHeaderVal, batchVal); } CAF_CM_EXIT; return diagRequestDoc; }
SmartPtrCResponseHeaderDoc ResponseHeaderXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ResponseHeaderXml", "parse"); SmartPtrCResponseHeaderDoc responseHeaderDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string versionVal = thisXml->findRequiredAttribute("version"); const std::string createdDateTimeVal = thisXml->findRequiredAttribute("createdDateTime"); const std::string sequenceNumberStrVal = thisXml->findRequiredAttribute("sequenceNumber"); uint32 sequenceNumberVal = 0; if (! sequenceNumberStrVal.empty()) { sequenceNumberVal = CStringConv::fromString<uint32>(sequenceNumberStrVal); } const std::string isFinalResponseStrVal = thisXml->findRequiredAttribute("isFinalResponse"); bool isFinalResponseVal = false; if (! isFinalResponseStrVal.empty()) { isFinalResponseVal = (isFinalResponseStrVal.compare("true") == 0) ? true : false; } const std::string sessionIdStrVal = thisXml->findOptionalAttribute("sessionId"); UUID sessionIdVal = CAFCOMMON_GUID_NULL; if (! sessionIdStrVal.empty()) { BasePlatform::UuidFromString(sessionIdStrVal.c_str(), sessionIdVal); } responseHeaderDoc.CreateInstance(); responseHeaderDoc->initialize( versionVal, createdDateTimeVal, sequenceNumberVal, isFinalResponseVal, sessionIdVal); } CAF_CM_EXIT; return responseHeaderDoc; }
SmartPtrCMgmtCollectInstancesCollectionDoc MgmtCollectInstancesCollectionXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("MgmtCollectInstancesCollectionXml", "parse"); SmartPtrCMgmtCollectInstancesCollectionDoc mgmtCollectInstancesCollectionDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const CXmlElement::SmartPtrCElementCollection collectInstancesChildrenXml = thisXml->findRequiredChildren("collectInstances"); std::deque<SmartPtrCMgmtCollectInstancesDoc> collectInstancesVal; if (! collectInstancesChildrenXml.IsNull() && ! collectInstancesChildrenXml->empty()) { for (TConstIterator<CXmlElement::CElementCollection> collectInstancesXmlIter(*collectInstancesChildrenXml); collectInstancesXmlIter; collectInstancesXmlIter++) { const SmartPtrCXmlElement collectInstancesXml = collectInstancesXmlIter->second; const SmartPtrCMgmtCollectInstancesDoc collectInstancesDoc = MgmtCollectInstancesXml::parse(collectInstancesXml); collectInstancesVal.push_back(collectInstancesDoc); } } mgmtCollectInstancesCollectionDoc.CreateInstance(); mgmtCollectInstancesCollectionDoc->initialize( collectInstancesVal); } CAF_CM_EXIT; return mgmtCollectInstancesCollectionDoc; }
SmartPtrCMultiPmeMgmtBatchCollectionDoc MultiPmeMgmtBatchCollectionXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("MultiPmeMgmtBatchCollectionXml", "parse"); SmartPtrCMultiPmeMgmtBatchCollectionDoc multiPmeMgmtBatchCollectionDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const CXmlElement::SmartPtrCElementCollection multiPmeBatchChildrenXml = thisXml->findRequiredChildren("multiPmeBatch"); std::deque<SmartPtrCMultiPmeMgmtBatchDoc> multiPmeBatchVal; if (! multiPmeBatchChildrenXml.IsNull() && ! multiPmeBatchChildrenXml->empty()) { for (TConstIterator<CXmlElement::CElementCollection> multiPmeBatchXmlIter(*multiPmeBatchChildrenXml); multiPmeBatchXmlIter; multiPmeBatchXmlIter++) { const SmartPtrCXmlElement multiPmeBatchXml = multiPmeBatchXmlIter->second; const SmartPtrCMultiPmeMgmtBatchDoc multiPmeBatchDoc = MultiPmeMgmtBatchXml::parse(multiPmeBatchXml); multiPmeBatchVal.push_back(multiPmeBatchDoc); } } multiPmeMgmtBatchCollectionDoc.CreateInstance(); multiPmeMgmtBatchCollectionDoc->initialize( multiPmeBatchVal); } CAF_CM_EXIT; return multiPmeMgmtBatchCollectionDoc; }
SmartPtrCActionClassInstanceCollectionDoc ActionClassInstanceCollectionXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ActionClassInstanceCollectionXml", "parse"); SmartPtrCActionClassInstanceCollectionDoc actionClassInstanceCollectionDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const CXmlElement::SmartPtrCElementCollection actionClassInstanceChildrenXml = thisXml->findRequiredChildren("actionClassInstance"); std::deque<SmartPtrCActionClassInstanceDoc> actionClassInstanceVal; if (! actionClassInstanceChildrenXml.IsNull() && ! actionClassInstanceChildrenXml->empty()) { for (TConstIterator<CXmlElement::CElementCollection> actionClassInstanceXmlIter(*actionClassInstanceChildrenXml); actionClassInstanceXmlIter; actionClassInstanceXmlIter++) { const SmartPtrCXmlElement actionClassInstanceXml = actionClassInstanceXmlIter->second; const SmartPtrCActionClassInstanceDoc actionClassInstanceDoc = ActionClassInstanceXml::parse(actionClassInstanceXml); actionClassInstanceVal.push_back(actionClassInstanceDoc); } } actionClassInstanceCollectionDoc.CreateInstance(); actionClassInstanceCollectionDoc->initialize( actionClassInstanceVal); } CAF_CM_EXIT; return actionClassInstanceCollectionDoc; }
SmartPtrCInstanceOperationCollectionDoc InstanceOperationCollectionXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("InstanceOperationCollectionXml", "parse"); SmartPtrCInstanceOperationCollectionDoc instanceOperationCollectionDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const CXmlElement::SmartPtrCElementCollection instanceOperationChildrenXml = thisXml->findRequiredChildren("instanceOperation"); std::deque<SmartPtrCInstanceOperationDoc> instanceOperationVal; if (! instanceOperationChildrenXml.IsNull() && ! instanceOperationChildrenXml->empty()) { for (TConstIterator<CXmlElement::CElementCollection> instanceOperationXmlIter(*instanceOperationChildrenXml); instanceOperationXmlIter; instanceOperationXmlIter++) { const SmartPtrCXmlElement instanceOperationXml = instanceOperationXmlIter->second; const SmartPtrCInstanceOperationDoc instanceOperationDoc = InstanceOperationXml::parse(instanceOperationXml); instanceOperationVal.push_back(instanceOperationDoc); } } instanceOperationCollectionDoc.CreateInstance(); instanceOperationCollectionDoc->initialize( instanceOperationVal); } CAF_CM_EXIT; return instanceOperationCollectionDoc; }
void ProviderEventResponseXml::add( const SmartPtrCProviderEventResponseDoc providerEventResponseDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ProviderEventResponseXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(providerEventResponseDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string pmeIdVal = providerEventResponseDoc->getPmeId(); CAF_CM_VALIDATE_STRING(pmeIdVal); thisXml->addAttribute("pmeId", pmeIdVal); const SmartPtrCResponseHeaderDoc responseHeaderVal = providerEventResponseDoc->getResponseHeader(); if (! responseHeaderVal.IsNull()) { const SmartPtrCXmlElement responseHeaderXml = thisXml->createAndAddElement("responseHeader"); ResponseHeaderXml::add(responseHeaderVal, responseHeaderXml); } const SmartPtrCEventManifestDoc manifestVal = providerEventResponseDoc->getManifest(); CAF_CM_VALIDATE_SMARTPTR(manifestVal); const SmartPtrCXmlElement manifestXml = thisXml->createAndAddElement("manifest"); EventManifestXml::add(manifestVal, manifestXml); const SmartPtrCEventKeyCollectionDoc eventKeyCollectionVal = providerEventResponseDoc->getEventKeyCollection(); if (! eventKeyCollectionVal.IsNull()) { const SmartPtrCXmlElement eventKeyCollectionXml = thisXml->createAndAddElement("eventKeyCollection"); EventKeyCollectionXml::add(eventKeyCollectionVal, eventKeyCollectionXml); } const SmartPtrCStatisticsDoc statisticsVal = providerEventResponseDoc->getStatistics(); if (! statisticsVal.IsNull()) { const SmartPtrCXmlElement statisticsXml = thisXml->createAndAddElement("statistics"); StatisticsXml::add(statisticsVal, statisticsXml); } } CAF_CM_EXIT; }
SmartPtrCMethodParameterDoc MethodParameterXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("MethodParameterXml", "parse"); SmartPtrCMethodParameterDoc methodParameterDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string nameStrVal = thisXml->findRequiredAttribute("name"); const std::string nameVal = nameStrVal; const std::string typeStrVal = thisXml->findRequiredAttribute("type"); PARAMETER_TYPE typeVal = PARAMETER_NONE; if (! typeStrVal.empty()) { typeVal = EnumConvertersXml::convertStringToParameterType(typeStrVal); } const std::string isOptionalStrVal = thisXml->findRequiredAttribute("isOptional"); bool isOptionalVal = false; if (! isOptionalStrVal.empty()) { isOptionalVal = (isOptionalStrVal.compare("true") == 0) ? true : false; } const std::string isListStrVal = thisXml->findOptionalAttribute("isList"); bool isListVal = false; if (! isListStrVal.empty()) { isListVal = (isListStrVal.compare("true") == 0) ? true : false; } const std::string defaultValStrVal = thisXml->findOptionalAttribute("default"); const std::string defaultValVal = defaultValStrVal; const std::string displayNameStrVal = thisXml->findOptionalAttribute("displayName"); const std::string displayNameVal = displayNameStrVal; const std::string descriptionStrVal = thisXml->findOptionalAttribute("description"); const std::string descriptionVal = descriptionStrVal; methodParameterDoc.CreateInstance(); methodParameterDoc->initialize( nameVal, typeVal, isOptionalVal, isListVal, defaultValVal, displayNameVal, descriptionVal); } CAF_CM_EXIT; return methodParameterDoc; }
std::deque<std::pair<std::string, std::string> > CConfigProvider::createXmlFilePropertyCollection( const std::string& filePath) const { CAF_CM_FUNCNAME_VALIDATE("createXmlFilePropertyCollection"); std::deque<std::pair<std::string, std::string> > propertyCollection; CAF_CM_ENTER { CAF_CM_VALIDATE_STRING(filePath); const SmartPtrCXmlElement rootXml = CXmlUtils::parseFile(filePath, std::string()); const std::string keyPath = rootXml->getName(); createXmlPropertyCollection(keyPath, rootXml, propertyCollection); } CAF_CM_EXIT; return propertyCollection; }
std::string CCafMessagePayload::getVersion() const { CAF_CM_FUNCNAME_VALIDATE("getVersion"); CAF_CM_PRECOND_ISINITIALIZED(_isInitialized); SmartPtrCXmlElement headerXml = _payloadXml->findOptionalChild("requestHeader"); if (headerXml.IsNull()) { headerXml = _payloadXml->findOptionalChild("responseHeader"); } std::string rc; if (headerXml.IsNull()) { rc = _payloadXml->findRequiredAttribute("version"); } else { rc = headerXml->findRequiredAttribute("version"); } return rc; }
void EventKeyXml::add( const SmartPtrCEventKeyDoc eventKeyDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("EventKeyXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(eventKeyDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string nameVal = eventKeyDoc->getName(); CAF_CM_VALIDATE_STRING(nameVal); thisXml->addAttribute("name", nameVal); const std::string valueVal = eventKeyDoc->getValue(); CAF_CM_VALIDATE_STRING(valueVal); thisXml->addAttribute("value", valueVal); } CAF_CM_EXIT; }
SmartPtrCPropertyDoc PropertyXml::parse( const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("PropertyXml", "parse"); SmartPtrCPropertyDoc propertyDoc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string nameStrVal = thisXml->findRequiredAttribute("name"); const std::string nameVal = nameStrVal; const std::string typeStrVal = thisXml->findRequiredAttribute("type"); PROPERTY_TYPE typeVal = PROPERTY_NONE; if (! typeStrVal.empty()) { typeVal = EnumConvertersXml::convertStringToPropertyType(typeStrVal); } const CXmlElement::SmartPtrCElementCollection valueChildrenXml = thisXml->findRequiredChildren("value"); std::deque<std::string> valueVal; if (! valueChildrenXml.IsNull() && ! valueChildrenXml->empty()) { for (TConstIterator<CXmlElement::CElementCollection> valueXmlIter(*valueChildrenXml); valueXmlIter; valueXmlIter++) { const SmartPtrCXmlElement valueXml = valueXmlIter->second; const std::string valueDoc = valueXml->getValue(); valueVal.push_back(valueDoc); } } propertyDoc.CreateInstance(); propertyDoc->initialize( nameVal, typeVal, valueVal); } CAF_CM_EXIT; return propertyDoc; }
void CConfigProvider::createXmlPropertyCollection( const std::string& keyPath, const SmartPtrCXmlElement& thisXml, std::deque<std::pair<std::string, std::string> >& propertyCollection) const { CAF_CM_FUNCNAME_VALIDATE("createXmlPropertyCollection"); CAF_CM_ENTER { CAF_CM_VALIDATE_STRING(keyPath); CAF_CM_VALIDATE_SMARTPTR(thisXml); // propertyCollection is optional const CXmlElement::SmartPtrCAttributeCollection attributeCollection = thisXml->getAllAttributes(); if (! attributeCollection.IsNull() && ! attributeCollection->empty()) { for (TConstIterator<CXmlElement::CAttributeCollection> attributeXmlIter(*attributeCollection); attributeXmlIter; attributeXmlIter++) { const std::string attributeName = attributeXmlIter->first; const std::string attributeValue = attributeXmlIter->second; const std::string newKeyPath = keyPath + _keyPathDelimStr + attributeName; propertyCollection.push_back(std::make_pair(newKeyPath, attributeValue)); } } const CXmlElement::SmartPtrCElementCollection childrenXml = thisXml->getAllChildren(); if (! childrenXml.IsNull() && ! childrenXml->empty()) { for (TConstIterator<CXmlElement::CElementCollection > childrenXmlIter(*childrenXml); childrenXmlIter; childrenXmlIter++) { const SmartPtrCXmlElement childXml = childrenXmlIter->second; const std::string newKeyPath = keyPath + _keyPathDelimStr + childXml->getName(); const std::string value = childXml->getValue(); if (! value.empty()) { propertyCollection.push_back(std::make_pair(newKeyPath, value)); } createXmlPropertyCollection(newKeyPath, childXml, propertyCollection); } } } CAF_CM_EXIT; }
void DiagRequestXml::add( const SmartPtrCDiagRequestDoc diagRequestDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("DiagRequestXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(diagRequestDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string clientIdVal = BasePlatform::UuidToString(diagRequestDoc->getClientId()); CAF_CM_VALIDATE_STRING(clientIdVal); thisXml->addAttribute("clientId", clientIdVal); const std::string requestIdVal = BasePlatform::UuidToString(diagRequestDoc->getRequestId()); CAF_CM_VALIDATE_STRING(requestIdVal); thisXml->addAttribute("requestId", requestIdVal); const std::string pmeIdVal = diagRequestDoc->getPmeId(); CAF_CM_VALIDATE_STRING(pmeIdVal); thisXml->addAttribute("pmeId", pmeIdVal); const SmartPtrCRequestHeaderDoc requestHeaderVal = diagRequestDoc->getRequestHeader(); CAF_CM_VALIDATE_SMARTPTR(requestHeaderVal); const SmartPtrCXmlElement requestHeaderXml = thisXml->createAndAddElement("requestHeader"); RequestHeaderXml::add(requestHeaderVal, requestHeaderXml); const SmartPtrCDiagBatchDoc batchVal = diagRequestDoc->getBatch(); CAF_CM_VALIDATE_SMARTPTR(batchVal); const SmartPtrCXmlElement batchXml = thisXml->createAndAddElement("batch"); DiagBatchXml::add(batchVal, batchXml); } CAF_CM_EXIT; }
void LoggingLevelElemXml::add( const SmartPtrCLoggingLevelElemDoc loggingLevelElemDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("LoggingLevelElemXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(loggingLevelElemDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string componentVal = EnumConvertersXml::convertLoggingComponentTypeToString(loggingLevelElemDoc->getComponent()); CAF_CM_VALIDATE_STRING(componentVal); thisXml->addAttribute("component", componentVal); const std::string levelVal = EnumConvertersXml::convertLoggingLevelTypeToString(loggingLevelElemDoc->getLevel()); CAF_CM_VALIDATE_STRING(levelVal); thisXml->addAttribute("level", levelVal); } CAF_CM_EXIT; }
std::string CInstallToMgmtRequestTransformerInstance::saveUninstallProviderJobToString( const SmartPtrCUninstallProviderJobDoc& uninstallProviderJob) { CAF_CM_STATIC_FUNC_VALIDATE("XmlRoots", "saveUninstallProviderJobToString"); std::string rc; CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(uninstallProviderJob); const std::string schemaNamespace = DocXmlUtils::getSchemaNamespace("fx"); const SmartPtrCXmlElement rootXml = CXmlUtils::createRootElement( "cafUninstallProviderJob", schemaNamespace); UninstallProviderJobXml::add(uninstallProviderJob, rootXml); rc = rootXml->saveToStringRaw(); } CAF_CM_EXIT; return rc; }