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; }
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 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; }
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; }
void CConfigProvider::setValue( const std::string& filePath, const std::string& encoding, const std::string& valueName, const std::string& valueData) const { CAF_CM_FUNCNAME("setValue"); CAF_CM_ENTER { CAF_CM_VALIDATE_STRING(filePath); CAF_CM_VALIDATE_STRING(encoding); CAF_CM_VALIDATE_STRING(valueName); CAF_CM_VALIDATE_STRING(valueData); if (encoding.compare("iniFileWithoutSection") == 0) { SmartPtrCIniFileWithoutSection iniFileWithoutSection; iniFileWithoutSection.CreateInstance(); iniFileWithoutSection->initialize(filePath); iniFileWithoutSection->setValue(valueName, valueData); } else if (encoding.compare("iniFile") == 0) { std::string sectionName; std::string keyName; parseIniFileValuePath(valueName, sectionName, keyName); SmartPtrCIniFile iniFile; iniFile.CreateInstance(); iniFile->initialize(filePath); iniFile->setValue(sectionName, keyName, valueData); } else if (encoding.compare("xmlFile") == 0) { std::string keyName; std::deque<std::string> keyPathCollection; parseKeyPath(valueName, keyPathCollection, keyName); const SmartPtrCXmlElement rootXml = CXmlUtils::parseFile(filePath, std::string()); const SmartPtrCXmlElement parentXml = findXmlElement(keyPathCollection, rootXml); const SmartPtrCXmlElement foundElement = parentXml->findOptionalChild(keyName); if (! foundElement.IsNull()) { foundElement->setValue(valueData); } else { const std::string foundAttribute = parentXml->findOptionalAttribute(keyName); if (! foundAttribute.empty()) { parentXml->setAttribute(keyName, valueData); } else { const SmartPtrCXmlElement createdElement = parentXml->createAndAddElement(keyName); createdElement->setValue(valueData); } } rootXml->saveToFile(filePath); } else { CAF_CM_EXCEPTIONEX_VA2(InvalidArgumentException, E_INVALIDARG, "URI encoding is not recognized - filePath: %s, encoding: %s", filePath.c_str(), encoding.c_str()); } } CAF_CM_EXIT; }
void ErrorResponseXml::add( const SmartPtrCErrorResponseDoc errorResponseDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ErrorResponseXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(errorResponseDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string clientIdVal = BasePlatform::UuidToString(errorResponseDoc->getClientId()); if (! clientIdVal.empty()) { thisXml->addAttribute("clientId", clientIdVal); } const std::string requestIdVal = BasePlatform::UuidToString(errorResponseDoc->getRequestId()); if (! requestIdVal.empty()) { thisXml->addAttribute("requestId", requestIdVal); } const std::string pmeIdVal = errorResponseDoc->getPmeId(); if (! pmeIdVal.empty()) { thisXml->addAttribute("pmeId", pmeIdVal); } const SmartPtrCResponseHeaderDoc responseHeaderVal = errorResponseDoc->getResponseHeader(); if (! responseHeaderVal.IsNull()) { const SmartPtrCXmlElement responseHeaderXml = thisXml->createAndAddElement("responseHeader"); ResponseHeaderXml::add(responseHeaderVal, responseHeaderXml); } const std::string errorMessageVal = errorResponseDoc->getErrorMessage(); if (! errorMessageVal.empty()) { const SmartPtrCXmlElement errorMessageXml = thisXml->createAndAddElement("errorMessage"); errorMessageXml->setValue(errorMessageVal); } } 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 JoinTypeXml::add( const SmartPtrCJoinTypeDoc joinTypeDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("JoinTypeXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(joinTypeDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string operandVal = EnumConvertersXml::convertOperatorTypeToString(joinTypeDoc->getOperand()); CAF_CM_VALIDATE_STRING(operandVal); thisXml->addAttribute("operand", operandVal); const SmartPtrCClassFieldDoc dataClassLeftVal = joinTypeDoc->getDataClassLeft(); CAF_CM_VALIDATE_SMARTPTR(dataClassLeftVal); const SmartPtrCXmlElement dataClassLeftXml = thisXml->createAndAddElement("dataClassLeft"); ClassFieldXml::add(dataClassLeftVal, dataClassLeftXml); const SmartPtrCClassFieldDoc dataClassRightVal = joinTypeDoc->getDataClassRight(); CAF_CM_VALIDATE_SMARTPTR(dataClassRightVal); const SmartPtrCXmlElement dataClassRightXml = thisXml->createAndAddElement("dataClassRight"); ClassFieldXml::add(dataClassRightVal, dataClassRightXml); const std::string descriptionVal = joinTypeDoc->getDescription(); if (! descriptionVal.empty()) { thisXml->addAttribute("description", descriptionVal); } } CAF_CM_EXIT; }
void InstallProviderSpecXml::add( const SmartPtrCInstallProviderSpecDoc installProviderSpecDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("InstallProviderSpecXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(installProviderSpecDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string clientIdVal = BasePlatform::UuidToString(installProviderSpecDoc->getClientId()); CAF_CM_VALIDATE_STRING(clientIdVal); thisXml->addAttribute("clientId", clientIdVal); const std::string providerNamespaceVal = installProviderSpecDoc->getProviderNamespace(); CAF_CM_VALIDATE_STRING(providerNamespaceVal); thisXml->addAttribute("providerNamespace", providerNamespaceVal); const std::string providerNameVal = installProviderSpecDoc->getProviderName(); CAF_CM_VALIDATE_STRING(providerNameVal); thisXml->addAttribute("providerName", providerNameVal); const std::string providerVersionVal = installProviderSpecDoc->getProviderVersion(); CAF_CM_VALIDATE_STRING(providerVersionVal); thisXml->addAttribute("providerVersion", providerVersionVal); const std::deque<SmartPtrCMinPackageElemDoc> packageValVal = installProviderSpecDoc->getPackageCollection(); CAF_CM_VALIDATE_STL(packageValVal); if (! packageValVal.empty()) { for (TConstIterator<std::deque<SmartPtrCMinPackageElemDoc> > packageValIter(packageValVal); packageValIter; packageValIter++) { const SmartPtrCXmlElement packageValXml = thisXml->createAndAddElement("package"); MinPackageElemXml::add(*packageValIter, packageValXml); } } thisXml->addAttribute("version", "1.0"); } CAF_CM_EXIT; }
void CmdlMetadataXml::add( const SmartPtrCCmdlMetadataDoc cmdlMetadataDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("CmdlMetadataXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(cmdlMetadataDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string nameVal = cmdlMetadataDoc->getName(); CAF_CM_VALIDATE_STRING(nameVal); thisXml->addAttribute("name", nameVal); const std::string valueVal = cmdlMetadataDoc->getValue(); CAF_CM_VALIDATE_STRING(valueVal); const SmartPtrCXmlElement valueXml = thisXml->createAndAddElement("value"); valueXml->setValue(valueVal); } CAF_CM_EXIT; }
void MultiPmeMgmtBatchCollectionXml::add( const SmartPtrCMultiPmeMgmtBatchCollectionDoc multiPmeMgmtBatchCollectionDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("MultiPmeMgmtBatchCollectionXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(multiPmeMgmtBatchCollectionDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::deque<SmartPtrCMultiPmeMgmtBatchDoc> multiPmeBatchVal = multiPmeMgmtBatchCollectionDoc->getMultiPmeBatch(); CAF_CM_VALIDATE_STL(multiPmeBatchVal); if (! multiPmeBatchVal.empty()) { for (TConstIterator<std::deque<SmartPtrCMultiPmeMgmtBatchDoc> > multiPmeBatchIter(multiPmeBatchVal); multiPmeBatchIter; multiPmeBatchIter++) { const SmartPtrCXmlElement multiPmeBatchXml = thisXml->createAndAddElement("multiPmeBatch"); MultiPmeMgmtBatchXml::add(*multiPmeBatchIter, multiPmeBatchXml); } } } CAF_CM_EXIT; }
void InstanceOperationCollectionXml::add( const SmartPtrCInstanceOperationCollectionDoc instanceOperationCollectionDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("InstanceOperationCollectionXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(instanceOperationCollectionDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::deque<SmartPtrCInstanceOperationDoc> instanceOperationVal = instanceOperationCollectionDoc->getInstanceOperationCollection(); CAF_CM_VALIDATE_STL(instanceOperationVal); if (! instanceOperationVal.empty()) { for (TConstIterator<std::deque<SmartPtrCInstanceOperationDoc> > instanceOperationIter(instanceOperationVal); instanceOperationIter; instanceOperationIter++) { const SmartPtrCXmlElement instanceOperationXml = thisXml->createAndAddElement("instanceOperation"); InstanceOperationXml::add(*instanceOperationIter, instanceOperationXml); } } } CAF_CM_EXIT; }
void SchemaSummaryXml::add( const SmartPtrCSchemaSummaryDoc schemaSummaryDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("SchemaSummaryXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(schemaSummaryDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string providerNamespaceVal = schemaSummaryDoc->getProviderNamespace(); CAF_CM_VALIDATE_STRING(providerNamespaceVal); thisXml->addAttribute("providerNamespace", providerNamespaceVal); const std::string providerNameVal = schemaSummaryDoc->getProviderName(); CAF_CM_VALIDATE_STRING(providerNameVal); thisXml->addAttribute("providerName", providerNameVal); const std::string providerVersionVal = schemaSummaryDoc->getProviderVersion(); CAF_CM_VALIDATE_STRING(providerVersionVal); thisXml->addAttribute("providerVersion", providerVersionVal); const SmartPtrCClassCollectionDoc classCollectionVal = schemaSummaryDoc->getClassCollection(); CAF_CM_VALIDATE_SMARTPTR(classCollectionVal); const SmartPtrCXmlElement classCollectionXml = thisXml->createAndAddElement("classCollection"); ClassCollectionXml::add(classCollectionVal, classCollectionXml); const std::string invokerPathVal = schemaSummaryDoc->getInvokerPath(); if (! invokerPathVal.empty()) { thisXml->addAttribute("invokerPath", invokerPathVal); } } CAF_CM_EXIT; }
void DataClassInstanceCollectionXml::add( const SmartPtrCDataClassInstanceCollectionDoc dataClassInstanceCollectionDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("DataClassInstanceCollectionXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(dataClassInstanceCollectionDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::deque<SmartPtrCDataClassInstanceDoc> dataClassInstanceVal = dataClassInstanceCollectionDoc->getDataClassInstanceCollection(); CAF_CM_VALIDATE_STL(dataClassInstanceVal); if (! dataClassInstanceVal.empty()) { for (TConstIterator<std::deque<SmartPtrCDataClassInstanceDoc> > dataClassInstanceIter(dataClassInstanceVal); dataClassInstanceIter; dataClassInstanceIter++) { const SmartPtrCXmlElement dataClassInstanceXml = thisXml->createAndAddElement("dataClassInstance"); DataClassInstanceXml::add(*dataClassInstanceIter, dataClassInstanceXml); } } } CAF_CM_EXIT; }
void ActionClassInstanceCollectionXml::add( const SmartPtrCActionClassInstanceCollectionDoc actionClassInstanceCollectionDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("ActionClassInstanceCollectionXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(actionClassInstanceCollectionDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::deque<SmartPtrCActionClassInstanceDoc> actionClassInstanceVal = actionClassInstanceCollectionDoc->getActionClassInstanceCollection(); CAF_CM_VALIDATE_STL(actionClassInstanceVal); if (! actionClassInstanceVal.empty()) { for (TConstIterator<std::deque<SmartPtrCActionClassInstanceDoc> > actionClassInstanceIter(actionClassInstanceVal); actionClassInstanceIter; actionClassInstanceIter++) { const SmartPtrCXmlElement actionClassInstanceXml = thisXml->createAndAddElement("actionClassInstance"); ActionClassInstanceXml::add(*actionClassInstanceIter, actionClassInstanceXml); } } } CAF_CM_EXIT; }
void AttachmentNameCollectionXml::add( const SmartPtrCAttachmentNameCollectionDoc attachmentNameCollectionDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("AttachmentNameCollectionXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(attachmentNameCollectionDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::deque<std::string> nameVal = attachmentNameCollectionDoc->getName(); CAF_CM_VALIDATE_STL(nameVal); if (! nameVal.empty()) { for (TConstIterator<std::deque<std::string> > nameIter(nameVal); nameIter; nameIter++) { const SmartPtrCXmlElement nameXml = thisXml->createAndAddElement("attachmentName"); nameXml->addAttribute("name", *nameIter); } } } CAF_CM_EXIT; }
void MgmtCollectInstancesCollectionXml::add( const SmartPtrCMgmtCollectInstancesCollectionDoc mgmtCollectInstancesCollectionDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("MgmtCollectInstancesCollectionXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(mgmtCollectInstancesCollectionDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::deque<SmartPtrCMgmtCollectInstancesDoc> collectInstancesVal = mgmtCollectInstancesCollectionDoc->getCollectInstancesCollection(); CAF_CM_VALIDATE_STL(collectInstancesVal); if (! collectInstancesVal.empty()) { for (TConstIterator<std::deque<SmartPtrCMgmtCollectInstancesDoc> > collectInstancesIter(collectInstancesVal); collectInstancesIter; collectInstancesIter++) { const SmartPtrCXmlElement collectInstancesXml = thisXml->createAndAddElement("collectInstances"); MgmtCollectInstancesXml::add(*collectInstancesIter, collectInstancesXml); } } } CAF_CM_EXIT; }
void LogicalRelationshipXml::add( const SmartPtrCLogicalRelationshipDoc logicalRelationshipDoc, const SmartPtrCXmlElement thisXml) { CAF_CM_STATIC_FUNC_VALIDATE("LogicalRelationshipXml", "add"); CAF_CM_ENTER { CAF_CM_VALIDATE_SMARTPTR(logicalRelationshipDoc); CAF_CM_VALIDATE_SMARTPTR(thisXml); const std::string namespaceValVal = logicalRelationshipDoc->getNamespaceVal(); CAF_CM_VALIDATE_STRING(namespaceValVal); thisXml->addAttribute("namespace", namespaceValVal); const std::string nameVal = logicalRelationshipDoc->getName(); CAF_CM_VALIDATE_STRING(nameVal); thisXml->addAttribute("name", nameVal); const std::string versionVal = logicalRelationshipDoc->getVersion(); CAF_CM_VALIDATE_STRING(versionVal); thisXml->addAttribute("version", versionVal); const std::string arityVal = EnumConvertersXml::convertArityTypeToString(logicalRelationshipDoc->getArity()); CAF_CM_VALIDATE_STRING(arityVal); thisXml->addAttribute("arity", arityVal); const SmartPtrCClassCardinalityDoc dataClassLeftVal = logicalRelationshipDoc->getDataClassLeft(); CAF_CM_VALIDATE_SMARTPTR(dataClassLeftVal); const SmartPtrCXmlElement dataClassLeftXml = thisXml->createAndAddElement("dataClassLeft"); ClassCardinalityXml::add(dataClassLeftVal, dataClassLeftXml); const SmartPtrCClassCardinalityDoc dataClassRightVal = logicalRelationshipDoc->getDataClassRight(); CAF_CM_VALIDATE_SMARTPTR(dataClassRightVal); const SmartPtrCXmlElement dataClassRightXml = thisXml->createAndAddElement("dataClassRight"); ClassCardinalityXml::add(dataClassRightVal, dataClassRightXml); const std::deque<SmartPtrCJoinTypeDoc> joinVal = logicalRelationshipDoc->getJoinCollection(); CAF_CM_VALIDATE_STL(joinVal); if (! joinVal.empty()) { for (TConstIterator<std::deque<SmartPtrCJoinTypeDoc> > joinIter(joinVal); joinIter; joinIter++) { const SmartPtrCXmlElement joinXml = thisXml->createAndAddElement("join"); JoinTypeXml::add(*joinIter, joinXml); } } const std::string descriptionVal = logicalRelationshipDoc->getDescription(); if (! descriptionVal.empty()) { thisXml->addAttribute("description", descriptionVal); } } CAF_CM_EXIT; }