// Configurable elements association bool CConfigurableDomain::addConfigurableElement(CConfigurableElement *pConfigurableElement, const CParameterBlackboard *pMainBlackboard, core::Results &infos) { // Already associated? if (containsConfigurableElement(pConfigurableElement)) { infos.push_back("Configurable element " + pConfigurableElement->getPath() + " already associated to configuration domain " + getName()); return false; } // Already owned? if (pConfigurableElement->belongsTo(this)) { infos.push_back("Configurable element " + pConfigurableElement->getPath() + " already owned by configuration domain " + getName()); return false; } // Do add doAddConfigurableElement(pConfigurableElement, infos, pMainBlackboard); return true; }
// Domain splitting bool CConfigurableDomain::split(CConfigurableElement *pConfigurableElement, core::Results &infos) { // Not associated? if (!containsConfigurableElement(pConfigurableElement)) { std::string strError = "Configurable element " + pConfigurableElement->getPath() + " not associated to configuration domain " + getName(); infos.push_back(strError); return false; } // Create sub domain areas for all configurable element's children size_t uiNbConfigurableElementChildren = pConfigurableElement->getNbChildren(); if (!uiNbConfigurableElementChildren) { std::string strError = "Configurable element " + pConfigurableElement->getPath() + " has no children to split configurable domain to"; infos.push_back(strError); return false; } for (size_t uiChild = 0; uiChild < uiNbConfigurableElementChildren; uiChild++) { CConfigurableElement *pChildConfigurableElement = static_cast<CConfigurableElement *>(pConfigurableElement->getChild(uiChild)); doAddConfigurableElement(pChildConfigurableElement, infos); } // Delegate to configurations size_t uiNbConfigurations = getNbChildren(); for (size_t uiChild = 0; uiChild < uiNbConfigurations; uiChild++) { CDomainConfiguration *pDomainConfiguration = static_cast<CDomainConfiguration *>(getChild(uiChild)); pDomainConfiguration->split(pConfigurableElement); } // Remove given configurable element from this domain // Note: we shouldn't need to recompute the sync set in that case, as the splitted element // should include the syncers of its children elements doRemoveConfigurableElement(pConfigurableElement, false); return true; }
bool CConfigurableDomain::restoreConfiguration(const string &configurationName, CParameterBlackboard *mainBlackboard, bool autoSync, core::Results &errors) const { string error; const CDomainConfiguration *configuration = findConfiguration(configurationName, error); if (configuration == NULL) { errors.push_back(error); return false; } // Delegate bool bSuccess = configuration->restore(mainBlackboard, autoSync && _bSequenceAware, &errors); // Record last applied configuration _pLastAppliedConfiguration = configuration; // Synchronize if (autoSync && !_bSequenceAware) { bSuccess &= _syncerSet.sync(*mainBlackboard, false, &errors); } return bSuccess; }
// Configuration application if required void CConfigurableDomains::apply(CParameterBlackboard *pParameterBlackboard, CSyncerSet &syncerSet, bool bForce, core::Results &infos) const { /// Delegate to domains // Start with domains that can be synchronized all at once (with passed syncer set) size_t uiNbConfigurableDomains = getNbChildren(); for (size_t child = 0; child < uiNbConfigurableDomains; child++) { const CConfigurableDomain *pChildConfigurableDomain = static_cast<const CConfigurableDomain *>(getChild(child)); std::string info; // Apply and collect syncers when relevant pChildConfigurableDomain->apply(pParameterBlackboard, &syncerSet, bForce, info); if (!info.empty()) { infos.push_back(info); } } // Synchronize those collected syncers syncerSet.sync(*pParameterBlackboard, false, nullptr); // Then deal with domains that need to synchronize along apply for (size_t child = 0; child < uiNbConfigurableDomains; child++) { const CConfigurableDomain *pChildConfigurableDomain = static_cast<const CConfigurableDomain *>(getChild(child)); std::string info; // Apply and synchronize when relevant pChildConfigurableDomain->apply(pParameterBlackboard, nullptr, bForce, info); if (!info.empty()) { infos.push_back(info); } } }
// Configurable element - domain association bool CConfigurableDomains::addConfigurableElementToDomain( const string &domainName, CConfigurableElement *element, const CParameterBlackboard *mainBlackboard, core::Results &infos) { // Find domain std::string error; CConfigurableDomain *domain = findConfigurableDomain(domainName, error); if (domain == nullptr) { infos.push_back(error); return false; } // Delegate return domain->addConfigurableElement(element, mainBlackboard, infos); }
// Config restore bool CConfigurableDomains::restoreConfiguration(const string &domainName, const string &configurationName, CParameterBlackboard *mainBlackboard, bool autoSync, core::Results &errors) const { string error; // Find domain const CConfigurableDomain *domain = findConfigurableDomain(domainName, error); if (domain == nullptr) { errors.push_back(error); return false; } // Delegate return domain->restoreConfiguration(configurationName, mainBlackboard, autoSync, errors); }
bool CConfigurableDomains::split(const string &domainName, CConfigurableElement *element, core::Results &infos) { // Find domain std::string error; CConfigurableDomain *domain = findConfigurableDomain(domainName, error); if (domain == nullptr) { infos.push_back(error); return false; } // Delegate domain->split(element, infos); return true; }
// Configurable elements association void CConfigurableDomain::doAddConfigurableElement(CConfigurableElement *pConfigurableElement, core::Results &infos, const CParameterBlackboard *pMainBlackboard) { // Inform configurable element pConfigurableElement->addAttachedConfigurableDomain(this); // Create associated syncer set CSyncerSet *pSyncerSet = new CSyncerSet; // Add to sync set the configurable element one pConfigurableElement->fillSyncerSet(*pSyncerSet); // Store it _configurableElementToSyncerSetMap[pConfigurableElement] = pSyncerSet; // Add it to global one _syncerSet += *pSyncerSet; // Inform configurations size_t uiNbConfigurations = getNbChildren(); for (size_t uiChild = 0; uiChild < uiNbConfigurations; uiChild++) { CDomainConfiguration *pDomainConfiguration = static_cast<CDomainConfiguration *>(getChild(uiChild)); pDomainConfiguration->addConfigurableElement(pConfigurableElement, pSyncerSet); } // Ensure area validity for that configurable element (if main blackboard provided) if (pMainBlackboard) { infos.push_back("Validating domain '" + getName() + "' against main blackboard for configurable element '" + pConfigurableElement->getPath() + "'"); // Need to validate against main blackboard validateAreas(pConfigurableElement, pMainBlackboard); } // Already associated descendend configurable elements need a merge of their configuration data mergeAlreadyAssociatedDescendantConfigurableElements(pConfigurableElement, infos); // Add to list _configurableElementList.push_back(pConfigurableElement); }
// Merge any descended configurable element to this one with this one void CConfigurableDomain::mergeAlreadyAssociatedDescendantConfigurableElements( CConfigurableElement *newElement, core::Results &infos) { std::list<CConfigurableElement *> mergedConfigurableElementList; ConfigurableElementListIterator it; // Browse all configurable elements (new one not yet in the list!) for (it = _configurableElementList.begin(); it != _configurableElementList.end(); ++it) { CConfigurableElement *pConfigurablePotentialDescendantElement = *it; if (pConfigurablePotentialDescendantElement->isDescendantOf(newElement)) { infos.push_back("In domain '" + getName() + "', merging descendant configurable element's configurations '" + pConfigurablePotentialDescendantElement->getName() + "' into its ascendant '" + newElement->getName() + "' ones"); // Merge configuration data mergeConfigurations(newElement, pConfigurablePotentialDescendantElement); // Keep track for removal mergedConfigurableElementList.push_back(pConfigurablePotentialDescendantElement); } } // Remove all merged elements (new one not yet in the list!) for (it = mergedConfigurableElementList.begin(); it != mergedConfigurableElementList.end(); ++it) { CConfigurableElement *pMergedConfigurableElement = *it; // Remove merged from configurable element from internal tracking list // Note: we shouldn't need to recompute the sync set in that case, as the merged to element // should include the syncers of merged from elements doRemoveConfigurableElement(pMergedConfigurableElement, false); } }