// 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 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;
}
// From IXmlSink
bool CSubsystem::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
{
// Context
CXmlParameterSerializingContext& parameterBuildContext = static_cast<CXmlParameterSerializingContext&>(serializingContext);
// Install temporary component library for further component creation
parameterBuildContext.setComponentLibrary(_pComponentLibrary);
CXmlElement childElement;
// XML populate ComponentLibrary
xmlElement.getChildElement("ComponentLibrary", childElement);
if (!_pComponentLibrary->fromXml(childElement, serializingContext)) {
return false;
}
// XML populate InstanceDefintion
xmlElement.getChildElement("InstanceDefintion", childElement);
if (!_pInstanceDefinition->fromXml(childElement, serializingContext)) {
return false;
}
// Create components
_pInstanceDefinition->createInstances(this);
// Execute mapping to create subsystem mapping entities
string strError;
if (!mapSubsystemElements(strError)) {
serializingContext.setError(strError);
return false;
}
// Endianness
_bBigEndian = xmlElement.getAttributeBoolean("Endianness", "Big");
return true;
}
// XML parsing
bool CConfigurableDomain::parseDomainConfigurations(const CXmlElement &xmlElement,
CXmlDomainImportContext &serializingContext)
{
// We're supposedly clean
assert(_configurableElementList.empty());
// Get Configurations element
CXmlElement xmlConfigurationsElement;
xmlElement.getChildElement("Configurations", xmlConfigurationsElement);
// Parse it and create domain configuration objects
return base::fromXml(xmlConfigurationsElement, serializingContext);
}
// 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;
}
