upstream/parameter/ConfigurableElement.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 "ConfigurableElement.h"
#include "MappingData.h"
#include "SyncerSet.h"
#include "ConfigurableDomain.h"
#include "ConfigurationAccessContext.h"
#include "ConfigurableElementAggregator.h"
#include "AreaConfiguration.h"
#include "Iterator.hpp"
#include "Utility.h"
#include "XmlParameterSerializingContext.h"
#include <assert.h>

#define base CElement

CConfigurableElement::CConfigurableElement(const std::string &strName) : base(strName)
{
}

bool CConfigurableElement::fromXml(const CXmlElement &xmlElement,
                                   CXmlSerializingContext &serializingContext)
{
    auto &context = static_cast<CXmlParameterSerializingContext &>(serializingContext);
    auto &accessContext = context.getAccessContext();

    if (accessContext.serializeSettings()) {
        // As serialization and deserialisation are handled through the *same* function
        // the (de)serialize object can not be const in `serializeXmlSettings` signature.
        // As a result a const_cast is unavoidable :(.
        // Fixme: split serializeXmlSettings in two functions (in and out) to avoid the `const_cast`
        return serializeXmlSettings(const_cast<CXmlElement &>(xmlElement),
                                    static_cast<CConfigurationAccessContext &>(accessContext));
    }
    return structureFromXml(xmlElement, serializingContext);
}

void CConfigurableElement::toXml(CXmlElement &xmlElement,
                                 CXmlSerializingContext &serializingContext) const
{
    auto &context = static_cast<CXmlParameterSerializingContext &>(serializingContext);
    auto &accessContext = context.getAccessContext();
    if (accessContext.serializeSettings()) {

        serializeXmlSettings(xmlElement, static_cast<CConfigurationAccessContext &>(accessContext));
    } else {

        structureToXml(xmlElement, serializingContext);
    }
}

// XML configuration settings parsing
bool CConfigurableElement::serializeXmlSettings(
    CXmlElement &xmlConfigurationSettingsElementContent,
    CConfigurationAccessContext &configurationAccessContext) const
{
    size_t uiNbChildren = getNbChildren();

    if (!configurationAccessContext.serializeOut()) {
        // Just do basic checks and propagate to children
        CXmlElement::CChildIterator it(xmlConfigurationSettingsElementContent);

        CXmlElement xmlChildConfigurableElementSettingsElement;

        // Propagate to children
        for (size_t index = 0; index < uiNbChildren; index++) {

            // Get child
            const CConfigurableElement *pChildConfigurableElement =
                static_cast<const CConfigurableElement *>(getChild(index));

            if (!it.next(xmlChildConfigurableElementSettingsElement)) {

                // Structure error
                configurationAccessContext.setError(
                    "Configuration settings parsing: missing child node " +
                    pChildConfigurableElement->getXmlElementName() + " (name:" +
                    pChildConfigurableElement->getName() + ") in " + getName());

                return false;
            }

            // Check element type matches in type
            if (xmlChildConfigurableElementSettingsElement.getType() !=
                pChildConfigurableElement->getXmlElementName()) {

                // "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 xml setting name is "Component".
                bool compatibilityCase =
                    (pChildConfigurableElement->getXmlElementName() == "ParameterBlock") &&
                    (xmlChildConfigurableElementSettingsElement.getType() == "Component");

                // Error if the compatibility case does not occur.
                if (!compatibilityCase) {

                    // Type error
                    configurationAccessContext.setError(
                        "Configuration settings parsing: Settings "
                        "for configurable element " +
                        pChildConfigurableElement->getQualifiedPath() +
                        " does not match expected type: " +
                        xmlChildConfigurableElementSettingsElement.getType() + " instead of " +
                        pChildConfigurableElement->getKind());
                    return false;
                }
            }

            // Check element type matches in name
            if (xmlChildConfigurableElementSettingsElement.getNameAttribute() !=
                pChildConfigurableElement->getName()) {

                // Name error
                configurationAccessContext.setError(
                    "Configuration settings parsing: Under configurable element " +
                    getQualifiedPath() + ", expected element name " +
                    pChildConfigurableElement->getName() + " but found " +
                    xmlChildConfigurableElementSettingsElement.getNameAttribute() + " instead");

                return false;
            }

            // Parse child configurable element's settings
            if (!pChildConfigurableElement->serializeXmlSettings(
                    xmlChildConfigurableElementSettingsElement, configurationAccessContext)) {

                return false;
            }
        }
        // There should remain no configurable element to parse
        if (it.next(xmlChildConfigurableElementSettingsElement)) {

            // Structure error
            configurationAccessContext.setError(
                "Configuration settings parsing: Unexpected xml element node " +
                xmlChildConfigurableElementSettingsElement.getType() + " in " + getQualifiedPath());

            return false;
        }
    } else {
        // Handle element name attribute
        xmlConfigurationSettingsElementContent.setNameAttribute(getName());

        // Propagate to children
        for (size_t index = 0; index < uiNbChildren; index++) {

            const CConfigurableElement *pChildConfigurableElement =
                static_cast<const CConfigurableElement *>(getChild(index));

            // Create corresponding child element
            CXmlElement xmlChildConfigurableElementSettingsElement;

            xmlConfigurationSettingsElementContent.createChild(
                xmlChildConfigurableElementSettingsElement,
                pChildConfigurableElement->getXmlElementName());

            // Propagate
            pChildConfigurableElement->serializeXmlSettings(
                xmlChildConfigurableElementSettingsElement, configurationAccessContext);
        }
    }
    // Done
    return true;
}

// AreaConfiguration creation
CAreaConfiguration *CConfigurableElement::createAreaConfiguration(
    const CSyncerSet *pSyncerSet) const
{
    return new CAreaConfiguration(this, pSyncerSet);
}

// Parameter access
bool CConfigurableElement::accessValue(CPathNavigator &pathNavigator, std::string &strValue,
                                       bool bSet,
                                       CParameterAccessContext &parameterAccessContext) const
{
    std::string *pStrChildName = pathNavigator.next();

    if (!pStrChildName) {

        parameterAccessContext.setError((bSet ? "Can't set " : "Can't get ") +
                                        pathNavigator.getCurrentPath() +
                                        " because it is not a parameter");

        return false;
    }

    const CConfigurableElement *pChild =
        static_cast<const CConfigurableElement *>(findChild(*pStrChildName));

    if (!pChild) {

        parameterAccessContext.setError("Path not found: " + pathNavigator.getCurrentPath());

        return false;
    }

    return pChild->accessValue(pathNavigator, strValue, bSet, parameterAccessContext);
}

// Whole element access
void CConfigurableElement::getSettingsAsBytes(std::vector<uint8_t> &bytes,
                                              CParameterAccessContext &parameterAccessContext) const
{
    bytes.resize(getFootPrint());

    parameterAccessContext.getParameterBlackboard()->readBytes(
        bytes, getOffset() - parameterAccessContext.getBaseOffset());
}

bool CConfigurableElement::setSettingsAsBytes(const std::vector<uint8_t> &bytes,
                                              CParameterAccessContext &parameterAccessContext) const
{
    CParameterBlackboard *pParameterBlackboard = parameterAccessContext.getParameterBlackboard();

    // Size
    size_t size = getFootPrint();

    // Check sizes match
    if (size != bytes.size()) {

        parameterAccessContext.setError(std::string("Wrong size: Expected: ") +
                                        std::to_string(size) + " Provided: " +
                                        std::to_string(bytes.size()));

        return false;
    }

    // Write bytes
    pParameterBlackboard->writeBytes(bytes, getOffset() - parameterAccessContext.getBaseOffset());

    if (not parameterAccessContext.getAutoSync()) {
        // Auto sync is not activated, sync will be defered until an explicit request
        return true;
    }

    CSyncerSet syncerSet;
    fillSyncerSet(syncerSet);
    core::Results res;
    if (not syncerSet.sync(*parameterAccessContext.getParameterBlackboard(), false, &res)) {

        parameterAccessContext.setError(utility::asString(res));
        return false;
    }
    return true;
}

std::list<const CConfigurableElement *> CConfigurableElement::getConfigurableElementContext() const
{
    std::list<const CConfigurableElement *> configurableElementPath;

    const CElement *element = this;
    while (element != nullptr and isOfConfigurableElementType(element)) {
        auto configurableElement = static_cast<const CConfigurableElement *>(element);

        configurableElementPath.push_back(configurableElement);
        element = element->getParent();
    }

    return configurableElementPath;
}

// Used for simulation and virtual subsystems
void CConfigurableElement::setDefaultValues(CParameterAccessContext &parameterAccessContext) const
{
    // Propagate to children
    size_t uiNbChildren = getNbChildren();

    for (size_t index = 0; index < uiNbChildren; index++) {

        const CConfigurableElement *pConfigurableElement =
            static_cast<const CConfigurableElement *>(getChild(index));

        pConfigurableElement->setDefaultValues(parameterAccessContext);
    }
}

// Element properties
void CConfigurableElement::showProperties(std::string &strResult) const
{
    base::showProperties(strResult);

    strResult += "Total size: " + getFootprintAsString() + "\n";
}

std::string CConfigurableElement::logValue(utility::ErrorContext &context) const
{
    return logValue(static_cast<CParameterAccessContext &>(context));
}

std::string CConfigurableElement::logValue(CParameterAccessContext & /*ctx*/) const
{
    // By default, an element does not have a value. Only leaf elements have
    // one. This method could be pure virtual but then, several derived classes
    // would need to implement it in order to simply return an empty string.
    return "";
}

// Offset
void CConfigurableElement::setOffset(size_t offset)
{
    // Assign offset locally
    _offset = offset;

    // Propagate to children
    size_t uiNbChildren = getNbChildren();

    for (size_t index = 0; index < uiNbChildren; index++) {

        CConfigurableElement *pConfigurableElement =
            static_cast<CConfigurableElement *>(getChild(index));

        pConfigurableElement->setOffset(offset);

        offset += pConfigurableElement->getFootPrint();
    }
}

size_t CConfigurableElement::getOffset() const
{
    return _offset;
}

// Memory
size_t CConfigurableElement::getFootPrint() const
{
    size_t uiSize = 0;
    size_t uiNbChildren = getNbChildren();

    for (size_t index = 0; index < uiNbChildren; index++) {

        const CConfigurableElement *pConfigurableElement =
            static_cast<const CConfigurableElement *>(getChild(index));

        uiSize += pConfigurableElement->getFootPrint();
    }

    return uiSize;
}

// Browse parent path to find syncer
ISyncer *CConfigurableElement::getSyncer() const
{
    // Check parent
    const CElement *pParent = getParent();

    if (isOfConfigurableElementType(pParent)) {

        return static_cast<const CConfigurableElement *>(pParent)->getSyncer();
    }
    return nullptr;
}

// Syncer set (me, ascendant or descendant ones)
void CConfigurableElement::fillSyncerSet(CSyncerSet &syncerSet) const
{
    //  Try me or ascendants
    ISyncer *pMineOrAscendantSyncer = getSyncer();

    if (pMineOrAscendantSyncer) {

        // Provide found syncer object
        syncerSet += pMineOrAscendantSyncer;

        // Done
        return;
    }
    // Fetch descendant ones
    fillSyncerSetFromDescendant(syncerSet);
}

// Syncer set (descendant)
void CConfigurableElement::fillSyncerSetFromDescendant(CSyncerSet &syncerSet) const
{
    // Dig
    size_t uiNbChildren = getNbChildren();

    for (size_t index = 0; index < uiNbChildren; index++) {

        const CConfigurableElement *pConfigurableElement =
            static_cast<const CConfigurableElement *>(getChild(index));

        pConfigurableElement->fillSyncerSetFromDescendant(syncerSet);
    }
}

// Configurable domain association
void CConfigurableElement::addAttachedConfigurableDomain(
    const CConfigurableDomain *pConfigurableDomain)
{
    _configurableDomainList.push_back(pConfigurableDomain);
}

void CConfigurableElement::removeAttachedConfigurableDomain(
    const CConfigurableDomain *pConfigurableDomain)
{
    _configurableDomainList.remove(pConfigurableDomain);
}

// Belonging domain
bool CConfigurableElement::belongsTo(const CConfigurableDomain *pConfigurableDomain) const
{
    if (containsConfigurableDomain(pConfigurableDomain)) {

        return true;
    }
    return belongsToDomainAscending(pConfigurableDomain);
}

// Belonging domains
void CConfigurableElement::getBelongingDomains(
    std::list<const CConfigurableDomain *> &configurableDomainList) const
{
    configurableDomainList.insert(configurableDomainList.end(), _configurableDomainList.begin(),
                                  _configurableDomainList.end());

    // Check parent
    const CElement *pParent = getParent();

    if (isOfConfigurableElementType(pParent)) {

        static_cast<const CConfigurableElement *>(pParent)->getBelongingDomains(
            configurableDomainList);
    }
}

void CConfigurableElement::listBelongingDomains(std::string &strResult, bool bVertical) const
{
    // Get belonging domain list
    std::list<const CConfigurableDomain *> configurableDomainList;

    getBelongingDomains(configurableDomainList);

    // Fill list
    listDomains(configurableDomainList, strResult, bVertical);
}

// Elements with no domains
void CConfigurableElement::listRogueElements(std::string &strResult) const
{
    // Get rogue element aggregate list (no associated domain)
    std::list<const CConfigurableElement *> rogueElementList;

    CConfigurableElementAggregator configurableElementAggregator(
        rogueElementList, &CConfigurableElement::hasNoDomainAssociated);

    configurableElementAggregator.aggegate(this);

    // Build list as std::string
    std::list<const CConfigurableElement *>::const_iterator it;

    for (it = rogueElementList.begin(); it != rogueElementList.end(); ++it) {

        const CConfigurableElement *pConfigurableElement = *it;

        strResult += pConfigurableElement->getPath() + "\n";
    }
}

bool CConfigurableElement::isRogue() const
{
    // Check not belonging to any domin from current level and towards ascendents
    if (getBelongingDomainCount() != 0) {

        return false;
    }

    // Get a list of elements (current + descendants) with no domains associated
    std::list<const CConfigurableElement *> rogueElementList;

    CConfigurableElementAggregator agregator(rogueElementList,
                                             &CConfigurableElement::hasNoDomainAssociated);

    agregator.aggegate(this);

    // Check only one element found which ought to be current one
    return (rogueElementList.size() == 1) && (rogueElementList.front() == this);
}

// Footprint as string
std::string CConfigurableElement::getFootprintAsString() const
{
    // Get size as string
    return std::to_string(getFootPrint()) + " byte(s)";
}

// Matching check for no domain association
bool CConfigurableElement::hasNoDomainAssociated() const
{
    return _configurableDomainList.empty();
}

// Matching check for no valid associated domains
bool CConfigurableElement::hasNoValidDomainAssociated() const
{
    if (_configurableDomainList.empty()) {

        // No domains associated
        return true;
    }

    ConfigurableDomainListConstIterator it;

    // Browse all configurable domains for validity checking
    for (it = _configurableDomainList.begin(); it != _configurableDomainList.end(); ++it) {

        const CConfigurableDomain *pConfigurableDomain = *it;

        if (pConfigurableDomain->isApplicableConfigurationValid(this)) {

            return false;
        }
    }

    return true;
}

// Owning domains
void CConfigurableElement::listAssociatedDomains(std::string &strResult, bool bVertical) const
{
    // Fill list
    listDomains(_configurableDomainList, strResult, bVertical);
}

size_t CConfigurableElement::getBelongingDomainCount() const
{
    // Get belonging domain list
    std::list<const CConfigurableDomain *> configurableDomainList;

    getBelongingDomains(configurableDomainList);

    return configurableDomainList.size();
}

void CConfigurableElement::listDomains(
    const std::list<const CConfigurableDomain *> &configurableDomainList, std::string &strResult,
    bool bVertical) const
{
    // Fill list
    ConfigurableDomainListConstIterator it;
    bool bFirst = true;

    // Browse all configurable domains for comparison
    for (it = configurableDomainList.begin(); it != configurableDomainList.end(); ++it) {

        const CConfigurableDomain *pConfigurableDomain = *it;

        if (!bVertical && !bFirst) {

            strResult += ", ";
        }

        strResult += pConfigurableDomain->getName();

        if (bVertical) {

            strResult += "\n";
        } else {

            bFirst = false;
        }
    }
}

bool CConfigurableElement::containsConfigurableDomain(
    const CConfigurableDomain *pConfigurableDomain) const
{
    ConfigurableDomainListConstIterator it;

    // Browse all configurable domains for comparison
    for (it = _configurableDomainList.begin(); it != _configurableDomainList.end(); ++it) {

        if (pConfigurableDomain == *it) {

            return true;
        }
    }
    return false;
}

// Belonging domain ascending search
bool CConfigurableElement::belongsToDomainAscending(
    const CConfigurableDomain *pConfigurableDomain) const
{
    // Check parent
    const CElement *pParent = getParent();

    if (isOfConfigurableElementType(pParent)) {

        return static_cast<const CConfigurableElement *>(pParent)->belongsTo(pConfigurableDomain);
    }
    return false;
}

// Belonging subsystem
const CSubsystem *CConfigurableElement::getBelongingSubsystem() const
{
    const CElement *pParent = getParent();

    // Stop at system class
    if (!pParent->getParent()) {

        return nullptr;
    }

    return static_cast<const CConfigurableElement *>(pParent)->getBelongingSubsystem();
}

// Check element is a parameter
bool CConfigurableElement::isParameter() const
{
    return false;
}

// Check parent is still of current type (by structure knowledge)
bool CConfigurableElement::isOfConfigurableElementType(const CElement *pParent) const
{
    assert(pParent);

    // Up to system class
    return !!pParent->getParent();
}