C++ (Cpp) SmartPtrCXmlElement::addAttribute Exemples

Exemple #1

Fichier : DiagDeleteValueXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #2

Fichier : PropertyXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #3

Fichier : ClassFieldXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #4

Fichier : ActionClassInstanceXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #5

Fichier : ResponseHeaderXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #6

Fichier : ErrorResponseXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #7

Fichier : EventKeyXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #8

Fichier : InstallProviderSpecXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #9

Fichier : DiagRequestXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #10

Fichier : LoggingLevelElemXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #11

Fichier : JoinTypeXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #12

Fichier : SchemaSummaryXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #13

Fichier : InstanceParameterXml.cpp Projet : bzed/pkg-open-vm-tools

void InstanceParameterXml::add(
	const SmartPtrCInstanceParameterDoc instanceParameterDoc,
	const SmartPtrCXmlElement thisXml) {
	CAF_CM_STATIC_FUNC_VALIDATE("InstanceParameterXml", "add");

	CAF_CM_ENTER {
		CAF_CM_VALIDATE_SMARTPTR(instanceParameterDoc);
		CAF_CM_VALIDATE_SMARTPTR(thisXml);

		const std::string nameVal = instanceParameterDoc->getName();
		CAF_CM_VALIDATE_STRING(nameVal);
		thisXml->addAttribute("name", nameVal);

		const std::string instanceNamespaceVal = instanceParameterDoc->getInstanceNamespace();
		CAF_CM_VALIDATE_STRING(instanceNamespaceVal);
		thisXml->addAttribute("instanceNamespace", instanceNamespaceVal);

		const std::string instanceNameVal = instanceParameterDoc->getInstanceName();
		CAF_CM_VALIDATE_STRING(instanceNameVal);
		thisXml->addAttribute("instanceName", instanceNameVal);

		const std::string instanceVersionVal = instanceParameterDoc->getInstanceVersion();
		CAF_CM_VALIDATE_STRING(instanceVersionVal);
		thisXml->addAttribute("instanceVersion", instanceVersionVal);

		const std::string isOptionalVal = instanceParameterDoc->getIsOptional() ? "true" : "false";
		CAF_CM_VALIDATE_STRING(isOptionalVal);
		thisXml->addAttribute("isOptional", isOptionalVal);

		const std::string isListVal = instanceParameterDoc->getIsList() ? "true" : "false";
		if (! isListVal.empty()) {
			thisXml->addAttribute("isList", isListVal);
		}

		const std::string displayNameVal = instanceParameterDoc->getDisplayName();
		if (! displayNameVal.empty()) {
			thisXml->addAttribute("displayName", displayNameVal);
		}

		const std::string descriptionVal = instanceParameterDoc->getDescription();
		if (! descriptionVal.empty()) {
			thisXml->addAttribute("description", descriptionVal);
		}
	}
	CAF_CM_EXIT;
}

Exemple #14

Fichier : DiagCollectInstancesXml.cpp Projet : bzed/pkg-open-vm-tools

void DiagCollectInstancesXml::add(
	const SmartPtrCDiagCollectInstancesDoc diagCollectInstancesDoc,
	const SmartPtrCXmlElement thisXml) {
	CAF_CM_STATIC_FUNC_VALIDATE("DiagCollectInstancesXml", "add");

	CAF_CM_ENTER {
		CAF_CM_VALIDATE_SMARTPTR(diagCollectInstancesDoc);
		CAF_CM_VALIDATE_SMARTPTR(thisXml);

		const std::string jobIdVal =
			BasePlatform::UuidToString(diagCollectInstancesDoc->getJobId());
		CAF_CM_VALIDATE_STRING(jobIdVal);
		thisXml->addAttribute("jobId", jobIdVal);
	}
	CAF_CM_EXIT;
}

Exemple #15

Fichier : ProviderEventResponseXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #16

Fichier : MethodParameterXml.cpp Projet : bzed/pkg-open-vm-tools

void MethodParameterXml::add(
	const SmartPtrCMethodParameterDoc methodParameterDoc,
	const SmartPtrCXmlElement thisXml) {
	CAF_CM_STATIC_FUNC_VALIDATE("MethodParameterXml", "add");

	CAF_CM_ENTER {
		CAF_CM_VALIDATE_SMARTPTR(methodParameterDoc);
		CAF_CM_VALIDATE_SMARTPTR(thisXml);

		const std::string nameVal = methodParameterDoc->getName();
		CAF_CM_VALIDATE_STRING(nameVal);
		thisXml->addAttribute("name", nameVal);

		const std::string typeVal =
			EnumConvertersXml::convertParameterTypeToString(methodParameterDoc->getType());
		CAF_CM_VALIDATE_STRING(typeVal);
		thisXml->addAttribute("type", typeVal);

		const std::string isOptionalVal = methodParameterDoc->getIsOptional() ? "true" : "false";
		CAF_CM_VALIDATE_STRING(isOptionalVal);
		thisXml->addAttribute("isOptional", isOptionalVal);

		const std::string isListVal = methodParameterDoc->getIsList() ? "true" : "false";
		if (! isListVal.empty()) {
			thisXml->addAttribute("isList", isListVal);
		}

		const std::string defaultValVal = methodParameterDoc->getDefaultVal();
		if (! defaultValVal.empty()) {
			thisXml->addAttribute("default", defaultValVal);
		}

		const std::string displayNameVal = methodParameterDoc->getDisplayName();
		if (! displayNameVal.empty()) {
			thisXml->addAttribute("displayName", displayNameVal);
		}

		const std::string descriptionVal = methodParameterDoc->getDescription();
		if (! descriptionVal.empty()) {
			thisXml->addAttribute("description", descriptionVal);
		}
	}
	CAF_CM_EXIT;
}

Exemple #17

Fichier : CmdlMetadataXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #18

Fichier : AttachmentNameCollectionXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}

Exemple #19

Fichier : UninstallProviderJobXml.cpp Projet : vmware/open-vm-tools

void UninstallProviderJobXml::add(
    const SmartPtrCUninstallProviderJobDoc uninstallProviderJobDoc,
    const SmartPtrCXmlElement thisXml) {
    CAF_CM_STATIC_FUNC_VALIDATE("UninstallProviderJobXml", "add");

    CAF_CM_ENTER {
        CAF_CM_VALIDATE_SMARTPTR(uninstallProviderJobDoc);
        CAF_CM_VALIDATE_SMARTPTR(thisXml);

        const std::string clientIdVal =
        BasePlatform::UuidToString(uninstallProviderJobDoc->getClientId());
        CAF_CM_VALIDATE_STRING(clientIdVal);
        thisXml->addAttribute("clientId", clientIdVal);

        const std::string jobIdVal =
        BasePlatform::UuidToString(uninstallProviderJobDoc->getJobId());
        CAF_CM_VALIDATE_STRING(jobIdVal);
        thisXml->addAttribute("jobId", jobIdVal);

        const std::string providerNamespaceVal = uninstallProviderJobDoc->getProviderNamespace();
        CAF_CM_VALIDATE_STRING(providerNamespaceVal);
        thisXml->addAttribute("providerNamespace", providerNamespaceVal);

        const std::string providerNameVal = uninstallProviderJobDoc->getProviderName();
        CAF_CM_VALIDATE_STRING(providerNameVal);
        thisXml->addAttribute("providerName", providerNameVal);

        const std::string providerVersionVal = uninstallProviderJobDoc->getProviderVersion();
        CAF_CM_VALIDATE_STRING(providerVersionVal);
        thisXml->addAttribute("providerVersion", providerVersionVal);

        const std::string packageOSTypeVal =
        EnumConvertersXml::convertPackageOSTypeToString(uninstallProviderJobDoc->getPackageOSType());
        CAF_CM_VALIDATE_STRING(packageOSTypeVal);
        thisXml->addAttribute("packageOSType", packageOSTypeVal);
    }
    CAF_CM_EXIT;
}

Exemple #20

Fichier : LogicalRelationshipXml.cpp Projet : bzed/pkg-open-vm-tools

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;
}