upstream/parameter/ConfigurableDomains.cpp

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