diff options
Diffstat (limited to 'upstream/parameter/ConfigurableDomains.cpp')
| -rw-r--r-- | upstream/parameter/ConfigurableDomains.cpp | 619 |
1 files changed, 619 insertions, 0 deletions
diff --git a/upstream/parameter/ConfigurableDomains.cpp b/upstream/parameter/ConfigurableDomains.cpp new file mode 100644 index 0000000..7c51083 --- /dev/null +++ b/upstream/parameter/ConfigurableDomains.cpp @@ -0,0 +1,619 @@ +/* + * Copyright (c) 2011-2015, Intel Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include <cassert> +#include "ConfigurableDomains.h" +#include "ConfigurableDomain.h" +#include "ConfigurableElement.h" + +#define base CElement + +using std::string; + +string CConfigurableDomains::getKind() const +{ + return "ConfigurableDomains"; +} + +bool CConfigurableDomains::childrenAreDynamic() const +{ + return true; +} + +// Ensure validity on whole domains from main blackboard +void CConfigurableDomains::validate(const CParameterBlackboard *pMainBlackboard) +{ + // Delegate to domains + size_t uiNbConfigurableDomains = getNbChildren(); + + for (size_t child = 0; child < uiNbConfigurableDomains; child++) { + + CConfigurableDomain *pChildConfigurableDomain = + static_cast<CConfigurableDomain *>(getChild(child)); + + pChildConfigurableDomain->validate(pMainBlackboard); + } +} + +// 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, NULL); + + // 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, NULL, bForce, info); + if (!info.empty()) { + infos.push_back(info); + } + } +} + +// From IXmlSource +void CConfigurableDomains::toXml(CXmlElement &xmlElement, + CXmlSerializingContext &serializingContext) const +{ + // Set attribute + xmlElement.setAttribute("SystemClassName", getName()); + + base::childrenToXml(xmlElement, serializingContext); +} + +// Configuration/Domains handling +/// Domains +bool CConfigurableDomains::createDomain(const string &strName, string &strError) +{ + // Already exists? + if (findChild(strName)) { + + strError = "Already existing configurable domain"; + + return false; + } + + // Creation/Hierarchy + addChild(new CConfigurableDomain(strName)); + + return true; +} + +bool CConfigurableDomains::addDomain(CConfigurableDomain &domain, bool bOverwrite, string &strError) +{ + string strErrorDrop; + + string strDomainName(domain.getName()); + CConfigurableDomain *pExistingDomain = findConfigurableDomain(strDomainName, strErrorDrop); + + if (pExistingDomain) { + if (!bOverwrite) { + strError = "Can't add domain \"" + strDomainName + + "\" because it already exists and overwrite was not requested."; + return false; + } + + deleteDomain(*pExistingDomain); + } + + addChild(&domain); + + return true; +} + +void CConfigurableDomains::deleteDomain(CConfigurableDomain &configurableDomain) +{ + removeChild(&configurableDomain); + + delete &configurableDomain; +} + +bool CConfigurableDomains::deleteDomain(const string &strName, string &strError) +{ + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strName, strError); + + if (pConfigurableDomain) { + deleteDomain(*pConfigurableDomain); + return true; + } + + return false; +} + +void CConfigurableDomains::deleteAllDomains() +{ + // remove Children + clean(); +} + +bool CConfigurableDomains::renameDomain(const string &strName, const string &strNewName, + string &strError) +{ + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strName, strError); + + if (!pConfigurableDomain) { + + return false; + } + + // Rename + return pConfigurableDomain->rename(strNewName, strError); +} + +bool CConfigurableDomains::setSequenceAwareness(const string &strDomain, bool bSequenceAware, + string &strError) +{ + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + + pConfigurableDomain->setSequenceAwareness(bSequenceAware); + + return true; +} + +bool CConfigurableDomains::getSequenceAwareness(const string &strDomain, bool &bSequenceAware, + string &strError) const +{ + const CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + + bSequenceAware = pConfigurableDomain->getSequenceAwareness(); + + return true; +} + +/// Configurations +bool CConfigurableDomains::listConfigurations(const string &strDomain, string &strResult) const +{ + const CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strResult); + + if (!pConfigurableDomain) { + + return false; + } + // delegate + pConfigurableDomain->listChildren(strResult); + + return true; +} + +bool CConfigurableDomains::createConfiguration(const string &strDomain, + const string &strConfiguration, + const CParameterBlackboard *pMainBlackboard, + string &strError) +{ + // Find domain + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + // Delegate + return pConfigurableDomain->createConfiguration(strConfiguration, pMainBlackboard, strError); +} + +bool CConfigurableDomains::deleteConfiguration(const string &strDomain, + const string &strConfiguration, string &strError) +{ + // Find domain + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + // Delegate + return pConfigurableDomain->deleteConfiguration(strConfiguration, strError); +} + +bool CConfigurableDomains::renameConfiguration(const string &strDomain, + const string &strConfigurationName, + const string &strNewConfigurationName, + string &strError) +{ + // Find domain + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + // Delegate + return pConfigurableDomain->renameConfiguration(strConfigurationName, strNewConfigurationName, + strError); +} + +bool CConfigurableDomains::listDomainElements(const string &strDomain, string &strResult) const +{ + // Find domain + const CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strResult); + + if (!pConfigurableDomain) { + + return false; + } + // Delegate + pConfigurableDomain->listAssociatedToElements(strResult); + + return true; +} + +bool CConfigurableDomains::split(const string &domainName, CConfigurableElement *element, + core::Results &infos) +{ + // Find domain + std::string error; + CConfigurableDomain *domain = findConfigurableDomain(domainName, error); + + if (domain == NULL) { + + infos.push_back(error); + return false; + } + // Delegate + domain->split(element, infos); + + return true; +} + +void CConfigurableDomains::listAssociatedElements(string &strResult) const +{ + std::set<const CConfigurableElement *> configurableElementSet; + + // Get all owned configurable elements + gatherAllOwnedConfigurableElements(configurableElementSet); + + // Fill result + std::set<const CConfigurableElement *>::const_iterator it; + + for (it = configurableElementSet.begin(); it != configurableElementSet.end(); ++it) { + + const CConfigurableElement *pConfigurableElement = *it; + + string strAssociatedDomainList; + + pConfigurableElement->listAssociatedDomains(strAssociatedDomainList, false); + + strResult += pConfigurableElement->getPath() + " [" + strAssociatedDomainList + "]\n"; + } +} + +void CConfigurableDomains::listConflictingElements(string &strResult) const +{ + std::set<const CConfigurableElement *> configurableElementSet; + + // Get all owned configurable elements + gatherAllOwnedConfigurableElements(configurableElementSet); + + // Fill result + std::set<const CConfigurableElement *>::const_iterator it; + + for (it = configurableElementSet.begin(); it != configurableElementSet.end(); ++it) { + + const CConfigurableElement *pConfigurableElement = *it; + + if (pConfigurableElement->getBelongingDomainCount() > 1) { + + string strBelongingDomainList; + + pConfigurableElement->listBelongingDomains(strBelongingDomainList, false); + + strResult += pConfigurableElement->getPath() + " contained in multiple domains: " + + strBelongingDomainList + "\n"; + } + } +} + +void CConfigurableDomains::listDomains(string &strResult) const +{ + // List domains + size_t uiNbConfigurableDomains = getNbChildren(); + + for (size_t child = 0; child < uiNbConfigurableDomains; child++) { + + const CConfigurableDomain *pChildConfigurableDomain = + static_cast<const CConfigurableDomain *>(getChild(child)); + + // Name + strResult += pChildConfigurableDomain->getName(); + + // Sequence awareness + if (pChildConfigurableDomain->getSequenceAwareness()) { + + strResult += " [sequence aware]"; + } + strResult += "\n"; + } +} + +// Gather configurable elements owned by any domain +void CConfigurableDomains::gatherAllOwnedConfigurableElements( + std::set<const CConfigurableElement *> &configurableElementSet) const +{ + // Delegate to domains + size_t uiNbConfigurableDomains = getNbChildren(); + + for (size_t child = 0; child < uiNbConfigurableDomains; child++) { + + const CConfigurableDomain *pChildConfigurableDomain = + static_cast<const CConfigurableDomain *>(getChild(child)); + + pChildConfigurableDomain->gatherConfigurableElements(configurableElementSet); + } +} + +// 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 == NULL) { + + errors.push_back(error); + return false; + } + // Delegate + return domain->restoreConfiguration(configurationName, mainBlackboard, autoSync, errors); +} + +// Config save +bool CConfigurableDomains::saveConfiguration(const string &strDomain, + const string &strConfiguration, + const CParameterBlackboard *pMainBlackboard, + string &strError) +{ + // Find domain + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + // Delegate + return pConfigurableDomain->saveConfiguration(strConfiguration, pMainBlackboard, strError); +} + +bool CConfigurableDomains::setElementSequence(const string &strDomain, + const string &strConfiguration, + const std::vector<string> &astrNewElementSequence, + string &strError) +{ + // Find domain + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + + // Delegate to domain + return pConfigurableDomain->setElementSequence(strConfiguration, astrNewElementSequence, + strError); +} + +bool CConfigurableDomains::getElementSequence(const string &strDomain, + const string &strConfiguration, + string &strResult) const +{ + // Find domain + const CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strResult); + + if (!pConfigurableDomain) { + + return false; + } + // Delegate to domain + return pConfigurableDomain->getElementSequence(strConfiguration, strResult); +} + +bool CConfigurableDomains::setApplicationRule( + const string &strDomain, const string &strConfiguration, const string &strApplicationRule, + const CSelectionCriteriaDefinition *pSelectionCriteriaDefinition, string &strError) +{ + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + + // Delegate to domain + return pConfigurableDomain->setApplicationRule(strConfiguration, strApplicationRule, + pSelectionCriteriaDefinition, strError); +} + +bool CConfigurableDomains::clearApplicationRule(const string &strDomain, + const string &strConfiguration, string &strError) +{ + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + + // Delegate to domain + return pConfigurableDomain->clearApplicationRule(strConfiguration, strError); +} + +bool CConfigurableDomains::getApplicationRule(const string &strDomain, + const string &strConfiguration, + string &strResult) const +{ + const CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strResult); + + if (!pConfigurableDomain) { + + return false; + } + + // Delegate to domain + return pConfigurableDomain->getApplicationRule(strConfiguration, strResult); +} + +// Last applied configurations +void CConfigurableDomains::listLastAppliedConfigurations(string &strResult) const +{ + // Browse domains + size_t uiNbConfigurableDomains = getNbChildren(); + + for (size_t child = 0; child < uiNbConfigurableDomains; child++) { + + const CConfigurableDomain *pChildConfigurableDomain = + static_cast<const CConfigurableDomain *>(getChild(child)); + + strResult += pChildConfigurableDomain->getName() + ": " + + pChildConfigurableDomain->getLastAppliedConfigurationName() + " [" + + pChildConfigurableDomain->getPendingConfigurationName() + "]\n"; + } +} + +// 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 == NULL) { + + infos.push_back(error); + return false; + } + // Delegate + return domain->addConfigurableElement(element, mainBlackboard, infos); +} + +bool CConfigurableDomains::removeConfigurableElementFromDomain( + const string &strDomain, CConfigurableElement *pConfigurableElement, string &strError) +{ + // Find domain + CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return false; + } + // Delegate + return pConfigurableDomain->removeConfigurableElement(pConfigurableElement, strError); +} + +CParameterBlackboard *CConfigurableDomains::findConfigurationBlackboard( + const string &strDomain, const string &strConfiguration, + const CConfigurableElement *pConfigurableElement, size_t &baseOffset, bool &bIsLastApplied, + string &strError) const +{ + // Find domain + const CConfigurableDomain *pConfigurableDomain = findConfigurableDomain(strDomain, strError); + + if (!pConfigurableDomain) { + + return NULL; + } + + // Check that element belongs to the domain + if (!pConfigurableElement->belongsTo(pConfigurableDomain)) { + + strError = "Element \"" + pConfigurableElement->getPath() + + "\" does not belong to domain \"" + strDomain + "\""; + + return NULL; + } + + // Find Configuration Blackboard and Base Offset + return pConfigurableDomain->findConfigurationBlackboard(strConfiguration, pConfigurableElement, + baseOffset, bIsLastApplied, strError); +} + +// Domain retrieval +CConfigurableDomain *CConfigurableDomains::findConfigurableDomain(const string &strDomain, + string &strError) +{ + // Call the const equivalent + return const_cast<CConfigurableDomain *>( + static_cast<const CConfigurableDomains *>(this)->findConfigurableDomain(strDomain, + strError)); +} + +const CConfigurableDomain *CConfigurableDomains::findConfigurableDomain(const string &strDomain, + string &strError) const +{ + // Find domain + const CConfigurableDomain *pConfigurableDomain = + static_cast<const CConfigurableDomain *>(findChild(strDomain)); + + if (!pConfigurableDomain) { + + strError = "Configurable domain " + strDomain + " not found"; + + return NULL; + } + + return pConfigurableDomain; +} |