// Parse configurable elements bool CConfigurableDomain::parseConfigurableElements(const CXmlElement &xmlElement, CXmlDomainImportContext &serializingContext) { CSystemClass &systemClass = serializingContext.getSystemClass(); // Get ConfigurableElements element CXmlElement xmlConfigurableElementsElement; xmlElement.getChildElement("ConfigurableElements", xmlConfigurableElementsElement); // Parse it and associate found configurable elements to it CXmlElement::CChildIterator it(xmlConfigurableElementsElement); CXmlElement xmlConfigurableElementElement; while (it.next(xmlConfigurableElementElement)) { // Locate configurable element string strConfigurableElementPath; xmlConfigurableElementElement.getAttribute("Path", strConfigurableElementPath); CPathNavigator pathNavigator(strConfigurableElementPath); string strError; // Is there an element and does it match system class name? if (!pathNavigator.navigateThrough(systemClass.getName(), strError)) { serializingContext.setError( "Could not find configurable element of path " + strConfigurableElementPath + " from ConfigurableDomain description " + getName() + " (" + strError + ")"); return false; } // Browse system class for configurable element CConfigurableElement *pConfigurableElement = static_cast<CConfigurableElement *>(systemClass.findDescendant(pathNavigator)); if (!pConfigurableElement) { serializingContext.setError("Could not find configurable element of path " + strConfigurableElementPath + " from ConfigurableDomain description " + getName()); return false; } // Add found element to domain core::Results infos; if (!addConfigurableElement(pConfigurableElement, NULL, infos)) { strError = utility::asString(infos); serializingContext.setError(strError); return false; } } return true; }
// Serialize one configuration for one configurable element bool CDomainConfiguration::importOneConfigurableElementSettings( CAreaConfiguration *areaConfiguration, CXmlElement &xmlConfigurableElementSettingsElement, CXmlDomainImportContext &context) { const CConfigurableElement *destination = areaConfiguration->getConfigurableElement(); // Check structure if (xmlConfigurableElementSettingsElement.getNbChildElements() != 1) { // Structure error context.setError("Struture error encountered while parsing settings of " + destination->getKind() + " " + destination->getName() + " in Configuration " + getPath()); return false; } // Element content CXmlElement xmlConfigurableElementSettingsElementContent; // Check name and kind if (!xmlConfigurableElementSettingsElement.getChildElement( destination->getXmlElementName(), destination->getName(), xmlConfigurableElementSettingsElementContent)) { // "Component" tag has been renamed to "ParameterBlock", but retro-compatibility shall // be ensured. // // So checking if this case occurs, i.e. element name is "ParameterBlock" // but found xml setting name is "Component". bool compatibilityCase = (destination->getXmlElementName() == "ParameterBlock") && xmlConfigurableElementSettingsElement.getChildElement( "Component", destination->getName(), xmlConfigurableElementSettingsElementContent); // Error if the compatibility case does not occur. if (!compatibilityCase) { context.setError("Couldn't find settings for " + destination->getXmlElementName() + " " + destination->getName() + " for Configuration " + getPath()); return false; } } // Create configuration access context string error; CConfigurationAccessContext configurationAccessContext(error, false); // Have domain configuration parse settings for configurable element bool success = areaConfiguration->serializeXmlSettings( xmlConfigurableElementSettingsElementContent, configurationAccessContext); context.appendToError(error); return success; }
// Parse settings bool CConfigurableDomain::parseSettings(const CXmlElement &xmlElement, CXmlDomainImportContext &serializingContext) { // Check we actually need to parse configuration settings if (!serializingContext.withSettings()) { // No parsing required return true; } // Get Settings element CXmlElement xmlSettingsElement; if (!xmlElement.getChildElement("Settings", xmlSettingsElement)) { // No settings, bail out successfully return true; } // Parse configuration settings CXmlElement::CChildIterator it(xmlSettingsElement); CXmlElement xmlConfigurationSettingsElement; while (it.next(xmlConfigurationSettingsElement)) { // Get domain configuration CDomainConfiguration *pDomainConfiguration = static_cast<CDomainConfiguration *>( findChild(xmlConfigurationSettingsElement.getNameAttribute())); if (!pDomainConfiguration) { serializingContext.setError("Could not find domain configuration referred to by" " configurable domain \"" + getName() + "\"."); return false; } // Have domain configuration parse settings for all configurable elements if (!pDomainConfiguration->parseSettings(xmlConfigurationSettingsElement, serializingContext)) { return false; } } return true; }
// XML configuration settings parsing bool CDomainConfiguration::parseSettings(CXmlElement &xmlConfigurationSettingsElement, CXmlDomainImportContext &context) { // Parse configurable element's configuration settings CXmlElement::CChildIterator it(xmlConfigurationSettingsElement); CXmlElement xmlConfigurableElementSettingsElement; auto insertLocation = begin(mAreaConfigurationList); while (it.next(xmlConfigurableElementSettingsElement)) { // Retrieve area configuration string configurableElementPath; xmlConfigurableElementSettingsElement.getAttribute("Path", configurableElementPath); auto areaConfiguration = findAreaConfigurationByPath(configurableElementPath); if (areaConfiguration == end(mAreaConfigurationList)) { context.setError("Configurable Element " + configurableElementPath + " referred to by Configuration " + getPath() + " not associated to Domain"); return false; } // Parse if (!importOneConfigurableElementSettings(areaConfiguration->get(), xmlConfigurableElementSettingsElement, context)) { return false; } // Take into account the new configuration order by moving the configuration associated to // the element to the n-th position of the configuration list. // It will result in prepending to the configuration list wit the configuration of all // elements found in XML, keeping the order of the processing of the XML file. mAreaConfigurationList.splice(insertLocation, mAreaConfigurationList, areaConfiguration); // areaConfiguration is still valid, but now refer to the reorderer list insertLocation = std::next(areaConfiguration); } return true; }