upstream/parameter/ParameterMgr.cpp

/*
 * Copyright (c) 2011-2016, 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 "version.h"
#include "ParameterMgr.h"
#include "ConfigurationAccessContext.h"
#include "XmlParameterSerializingContext.h"
#include "XmlElementSerializingContext.h"
#include "SystemClass.h"
#include "ElementLibrarySet.h"
#include "SubsystemLibrary.h"
#include "NamedElementBuilderTemplate.h"
#include "KindElementBuilderTemplate.h"
#include "ElementBuilderTemplate.h"
#include "SelectionCriterionType.h"
#include "SubsystemElementBuilder.h"
#include "FileIncluderElementBuilder.h"
#include "SelectionCriteria.h"
#include "ComponentType.h"
#include "ComponentInstance.h"
#include "ParameterBlockType.h"
#include "BooleanParameterType.h"
#include "IntegerParameterType.h"
#include "FixedPointParameterType.h"
#include "FloatingPointParameterType.h"
#include "ParameterBlackboard.h"
#include "Parameter.h"
#include "ParameterAccessContext.h"
#include "ParameterFrameworkConfiguration.h"
#include "FrameworkConfigurationGroup.h"
#include "PluginLocation.h"
#include "SubsystemPlugins.h"
#include "FrameworkConfigurationLocation.h"
#include "ConfigurableDomains.h"
#include "ConfigurableDomain.h"
#include "DomainConfiguration.h"
#include "XmlDomainSerializingContext.h"
#include "XmlDomainExportContext.h"
#include "XmlDomainImportContext.h"
#include "BitParameterBlockType.h"
#include "BitParameterType.h"
#include "StringParameterType.h"
#include "EnumParameterType.h"
#include "BackgroundRemoteProcessorServer.h"
#include "ElementLocator.h"
#include "CompoundRule.h"
#include "SelectionCriterionRule.h"
#include "SimulatedBackSynchronizer.h"
#include "HardwareBackSynchronizer.h"
#include <cassert>
#include "ParameterHandle.h"
#include "LinearParameterAdaptation.h"
#include "LogarithmicParameterAdaptation.h"
#include "EnumValuePair.h"
#include "Subsystem.h"
#include "XmlStreamDocSink.h"
#include "XmlMemoryDocSink.h"
#include "XmlDocSource.h"
#include "XmlMemoryDocSource.h"
#include "SelectionCriteriaDefinition.h"
#include "Utility.h"
#include "Memory.hpp"
#include <sstream>
#include <fstream>
#include <algorithm>
#include <stdexcept>
#include <mutex>
#include <iomanip>
#include "convert.hpp"

#define base CElement

/** Private macro helper to declare a new context
 *
 * Context declaration always need logger and logging prefix to be
 * passed as parameters.
 * This macro aims to avoid this boring notation.
 * This macro should be called only once in a scope. Nested scopes can
 * call this macro too, as variable shadowing is supported.
 */
#define LOG_CONTEXT(contextTitle) core::log::Context context(_logger, contextTitle)

#ifdef SIMULATION
// In simulation, back synchronization of the blackboard won't probably work
// We need to ensure though the blackboard is initialized with valid data
typedef CSimulatedBackSynchronizer BackSynchronizer;
#else
// Real back synchronizer from subsystems
typedef CHardwareBackSynchronizer BackSynchronizer;
#endif

using std::string;
using std::list;
using std::vector;
using std::ostringstream;
using std::ofstream;
using std::ifstream;
using std::mutex;
using std::lock_guard;

// FIXME: integrate ParameterMgr to core namespace
using namespace core;

// Used for remote processor server creation
typedef IRemoteProcessorServerInterface *(*CreateRemoteProcessorServer)(
    uint16_t uiPort, IRemoteCommandHandler *pCommandHandler);

// Config File System looks normally like this:
// ---------------------------------------------
//|-- <ParameterFrameworkConfiguration>.xml
//|-- schemas
//|   `-- *.xsd
//|-- Settings
//|   `-- <SystemClassName folder>*
//|       |-- <ConfigurableDomains>.xml
//|       `-- <Settings>.bin?
//`-- Structure
//    `-- <SystemClassName folder>*
//        |-- <SystemClassName>Class.xml
//        `-- <Subsystem>.xml*
// --------------------------------------------

// Remote command parser array
const CParameterMgr::SRemoteCommandParserItem CParameterMgr::gastRemoteCommandParserItems[] = {

    /// Version
    {"version", &CParameterMgr::versionCommandProcess, 0, "", "Show version"},

    /// Status
    {"status", &CParameterMgr::statusCommandProcess, 0, "", "Show current status"},

    /// Tuning Mode
    {"setTuningMode", &CParameterMgr::setTuningModeCommandProcess, 1, "on|off*",
     "Turn on or off Tuning Mode"},
    {"getTuningMode", &CParameterMgr::getTuningModeCommandProcess, 0, "", "Show Tuning Mode"},

    /// Value Space
    {"setValueSpace", &CParameterMgr::setValueSpaceCommandProcess, 1, "raw|real*",
     "Assigns Value Space used for parameter value interpretation"},
    {"getValueSpace", &CParameterMgr::getValueSpaceCommandProcess, 0, "", "Show Value Space"},

    /// Output Raw Format
    {"setOutputRawFormat", &CParameterMgr::setOutputRawFormatCommandProcess, 1, "dec*|hex",
     "Assigns format used to output parameter values when in raw Value Space"},
    {"getOutputRawFormat", &CParameterMgr::getOutputRawFormatCommandProcess, 0, "",
     "Show Output Raw Format"},

    /// Sync
    {"setAutoSync", &CParameterMgr::setAutoSyncCommandProcess, 1, "on*|off",
     "Turn on or off automatic synchronization to hardware while in Tuning Mode"},
    {"getAutoSync", &CParameterMgr::getAutoSyncCommandProcess, 0, "", "Show Auto Sync state"},
    {"sync", &CParameterMgr::syncCommandProcess, 0, "",
     "Synchronize current settings to hardware while in Tuning Mode and Auto Sync off"},

    /// Criteria
    {"listCriteria", &CParameterMgr::listCriteriaCommandProcess, 0, "[CSV|XML]",
     "List selection criteria"},

    /// Domains
    {"listDomains", &CParameterMgr::listDomainsCommandProcess, 0, "", "List configurable domains"},
    {"dumpDomains", &CParameterMgr::dumpDomainsCommandProcess, 0, "",
     "Show all domains and configurations, including applicability conditions"},
    {"createDomain", &CParameterMgr::createDomainCommandProcess, 1, "<domain>",
     "Create new configurable domain"},
    {"deleteDomain", &CParameterMgr::deleteDomainCommandProcess, 1, "<domain>",
     "Delete configurable domain"},
    {"deleteAllDomains", &CParameterMgr::deleteAllDomainsCommandProcess, 0, "",
     "Delete all configurable domains"},
    {"renameDomain", &CParameterMgr::renameDomainCommandProcess, 2, "<domain> <new name>",
     "Rename configurable domain"},
    {"setSequenceAwareness", &CParameterMgr::setSequenceAwarenessCommandProcess, 1,
     "<domain> true|false*", "Set configurable domain sequence awareness"},
    {"getSequenceAwareness", &CParameterMgr::getSequenceAwarenessCommandProcess, 1, "<domain>",
     "Get configurable domain sequence awareness"},
    {"listDomainElements", &CParameterMgr::listDomainElementsCommandProcess, 1, "<domain>",
     "List elements associated to configurable domain"},
    {"addElement", &CParameterMgr::addElementCommandProcess, 2, "<domain> <elem path>",
     "Associate element at given path to configurable domain"},
    {"removeElement", &CParameterMgr::removeElementCommandProcess, 2, "<domain> <elem path>",
     "Dissociate element at given path from configurable domain"},
    {"splitDomain", &CParameterMgr::splitDomainCommandProcess, 2, "<domain> <elem path>",
     "Split configurable domain at given associated element path"},

    /// Configurations
    {"listConfigurations", &CParameterMgr::listConfigurationsCommandProcess, 1, "<domain>",
     "List domain configurations"},
    {"createConfiguration", &CParameterMgr::createConfigurationCommandProcess, 2,
     "<domain> <configuration>", "Create new domain configuration"},
    {"deleteConfiguration", &CParameterMgr::deleteConfigurationCommandProcess, 2,
     "<domain> <configuration>", "Delete domain configuration"},
    {"renameConfiguration", &CParameterMgr::renameConfigurationCommandProcess, 3,
     "<domain> <configuration> <new name>", "Rename domain configuration"},
    {"saveConfiguration", &CParameterMgr::saveConfigurationCommandProcess, 2,
     "<domain> <configuration>", "Save current settings into configuration"},
    {"restoreConfiguration", &CParameterMgr::restoreConfigurationCommandProcess, 2,
     "<domain> <configuration>", "Restore current settings from configuration"},
    {"setElementSequence", &CParameterMgr::setElementSequenceCommandProcess, 3,
     "<domain> <configuration> <elem path list>",
     "Set element application order for configuration"},
    {"getElementSequence", &CParameterMgr::getElementSequenceCommandProcess, 2,
     "<domain> <configuration>", "Get element application order for configuration"},
    {"setRule", &CParameterMgr::setRuleCommandProcess, 3, "<domain> <configuration> <rule>",
     "Set configuration application rule"},
    {"clearRule", &CParameterMgr::clearRuleCommandProcess, 2, "<domain> <configuration>",
     "Clear configuration application rule"},
    {"getRule", &CParameterMgr::getRuleCommandProcess, 2, "<domain> <configuration>",
     "Get configuration application rule"},

    /// Elements/Parameters
    {"listElements", &CParameterMgr::listElementsCommandProcess, 1, "<elem path>|/",
     "List elements under element at given path or root"},
    {"listParameters", &CParameterMgr::listParametersCommandProcess, 1, "<elem path>|/",
     "List parameters under element at given path or root"},
    {"getElementStructureXML", &CParameterMgr::getElementStructureXMLCommandProcess, 1,
     "<elem path>", "Get structure of element at given path in XML format"},
    {"getElementBytes", &CParameterMgr::getElementBytesCommandProcess, 1, "<elem path>",
     "Get settings of element at given path in Byte Array format"},
    {"setElementBytes", &CParameterMgr::setElementBytesCommandProcess, 2, "<elem path> <values>",
     "Set settings of element at given path in Byte Array format"},
    {"getElementXML", &CParameterMgr::getElementXMLCommandProcess, 1, "<elem path>",
     "Get settings of element at given path in XML format"},
    {"setElementXML", &CParameterMgr::setElementXMLCommandProcess, 2, "<elem path> <values>",
     "Set settings of element at given path in XML format"},
    {"dumpElement", &CParameterMgr::dumpElementCommandProcess, 1, "<elem path>",
     "Dump structure and content of element at given path"},
    {"getElementSize", &CParameterMgr::getElementSizeCommandProcess, 1, "<elem path>",
     "Show size of element at given path"},
    {"showProperties", &CParameterMgr::showPropertiesCommandProcess, 1, "<elem path>",
     "Show properties of element at given path"},
    {"getParameter", &CParameterMgr::getParameterCommandProcess, 1, "<param path>",
     "Get value for parameter at given path"},
    {"setParameter", &CParameterMgr::setParameterCommandProcess, 2, "<param path> <value>",
     "Set value for parameter at given path"},
    {"listBelongingDomains", &CParameterMgr::listBelongingDomainsCommandProcess, 1, "<elem path>",
     "List domain(s) element at given path belongs to"},
    {"listAssociatedDomains", &CParameterMgr::listAssociatedDomainsCommandProcess, 1, "<elem path>",
     "List domain(s) element at given path is associated to"},
    {"getConfigurationParameter", &CParameterMgr::getConfigurationParameterCommandProcess, 3,
     "<domain> <configuration> <param path>",
     "Get value for parameter at given path from configuration"},
    {"setConfigurationParameter", &CParameterMgr::setConfigurationParameterCommandProcess, 4,
     "<domain> <configuration> <param path> <value>",
     "Set value for parameter at given path to configuration"},
    {"showMapping", &CParameterMgr::showMappingCommandProcess, 1, "<elem path>",
     "Show mapping for an element at given path"},

    /// Browse
    {"listAssociatedElements", &CParameterMgr::listAssociatedElementsCommandProcess, 0, "",
     "List element sub-trees associated to at least one configurable domain"},
    {"listConflictingElements", &CParameterMgr::listConflictingElementsCommandProcess, 0, "",
     "List element sub-trees contained in more than one configurable domain"},
    {"listRogueElements", &CParameterMgr::listRogueElementsCommandProcess, 0, "",
     "List element sub-trees owned by no configurable domain"},

    /// Settings Import/Export
    {"exportDomainsXML", &CParameterMgr::exportDomainsXMLCommandProcess, 1, "<file path> ",
     "Export domains to an XML file (provide an absolute path or relative"
     "to the client's working directory)"},
    {"importDomainsXML", &CParameterMgr::importDomainsXMLCommandProcess, 1, "<file path>",
     "Import domains from an XML file (provide an absolute path or relative"
     "to the client's working directory)"},
    {"exportDomainsWithSettingsXML", &CParameterMgr::exportDomainsWithSettingsXMLCommandProcess, 1,
     "<file path> ",
     "Export domains including settings to XML file (provide an absolute path or relative"
     "to the client's working directory)"},
    {"exportDomainWithSettingsXML", &CParameterMgr::exportDomainWithSettingsXMLCommandProcess, 2,
     "<domain> <file path> ", "Export a single given domain including settings to XML file"
                              " (provide an absolute path or relative to the client's"
                              " working directory)"},
    {"importDomainsWithSettingsXML", &CParameterMgr::importDomainsWithSettingsXMLCommandProcess, 1,
     "<file path>",
     "Import domains including settings from XML file (provide an absolute path or relative"
     "to the client's working directory)"},
    {"importDomainWithSettingsXML", &CParameterMgr::importDomainWithSettingsXMLCommandProcess, 1,
     "<file path> [overwrite]",
     "Import a single domain including settings from XML file."
     " Does not overwrite an existing domain unless 'overwrite' is passed as second"
     " argument. Provide an absolute path or relative to the client's working directory)"},
    {"getDomainsWithSettingsXML", &CParameterMgr::getDomainsWithSettingsXMLCommandProcess, 0, "",
     "Print domains including settings as XML"},
    {"getDomainWithSettingsXML", &CParameterMgr::getDomainWithSettingsXMLCommandProcess, 1,
     "<domain>", "Print the given domain including settings as XML"},
    {"setDomainsWithSettingsXML", &CParameterMgr::setDomainsWithSettingsXMLCommandProcess, 1,
     "<xml configurable domains>", "Import domains including settings from XML string"},
    {"setDomainWithSettingsXML", &CParameterMgr::setDomainWithSettingsXMLCommandProcess, 1,
     "<xml configurable domain> [overwrite]",
     "Import domains including settings from XML"
     " string. Does not overwrite an existing domain unless 'overwrite' is passed as second"
     " argument"},
    /// Structure Export
    {"getSystemClassXML", &CParameterMgr::getSystemClassXMLCommandProcess, 0, "",
     "Print parameter structure as XML"},
    /// Deprecated Commands
    {"getDomainsXML", &CParameterMgr::getDomainsWithSettingsXMLCommandProcess, 0, "",
     "DEPRECATED COMMAND, please use getDomainsWithSettingsXML"},

};

// Remote command parsers array Size
CParameterMgr::CParameterMgr(const string &strConfigurationFilePath, log::ILogger &logger)
    : _pMainParameterBlackboard(new CParameterBlackboard),
      _pElementLibrarySet(new CElementLibrarySet),
      _xmlConfigurationUri(CXmlDocSource::mkUri(strConfigurationFilePath, "")), _logger(logger)
{
    // Deal with children
    addChild(new CParameterFrameworkConfiguration);
    addChild(new CSelectionCriteria);
    addChild(new CSystemClass(_logger));
    addChild(new CConfigurableDomains);
}

CParameterMgr::~CParameterMgr()
{
    // Children
    delete _pRemoteProcessorServer;
    delete _pMainParameterBlackboard;
    delete _pElementLibrarySet;
}

string CParameterMgr::getKind() const
{
    return "ParameterMgr";
}

// Version
string CParameterMgr::getVersion() const
{
    return PARAMETER_FRAMEWORK_VERSION;
}

bool CParameterMgr::load(string &strError)
{
    LOG_CONTEXT("Loading");

    feedElementLibraries();

    // Load Framework configuration
    if (!loadFrameworkConfiguration(strError)) {

        return false;
    }

    if (!loadSubsystems(strError)) {

        return false;
    }

    // Load structure
    if (!loadStructure(strError)) {

        return false;
    }

    // Load settings
    if (!loadSettings(strError)) {

        return false;
    }

    // Init flow of element tree
    if (!init(strError)) {

        return false;
    }

    {
        LOG_CONTEXT("Main blackboard back synchronization");

        // Back synchronization for areas in parameter blackboard not covered by any domain
        BackSynchronizer(getConstSystemClass(), _pMainParameterBlackboard).sync();
    }

    // We're done loading the settings and back synchronizing
    CConfigurableDomains *pConfigurableDomains = getConfigurableDomains();

    // We need to ensure all domains are valid
    pConfigurableDomains->validate(_pMainParameterBlackboard);

    // Log selection criterion states
    {
        LOG_CONTEXT("Criterion states");

        const CSelectionCriteria *selectionCriteria = getConstSelectionCriteria();

        list<string> criteria;
        selectionCriteria->listSelectionCriteria(criteria, true, false);

        info() << criteria;
    }

    // Subsystem can not ask for resync as they have not been synced yet
    getSystemClass()->cleanSubsystemsNeedToResync();

    // At initialization, check subsystems that need resync
    doApplyConfigurations(true);

    // Start remote processor server if appropriate
    return handleRemoteProcessingInterface(strError);
}

bool CParameterMgr::loadFrameworkConfiguration(string &strError)
{
    LOG_CONTEXT("Loading framework configuration");

    // Parse Structure XML file
    CXmlElementSerializingContext elementSerializingContext(strError);

    _xmlDoc *doc =
        CXmlDocSource::mkXmlDoc(_xmlConfigurationUri, true, true, elementSerializingContext);
    if (doc == NULL) {
        return false;
    }

    if (!xmlParse(elementSerializingContext, getFrameworkConfiguration(), doc, _xmlConfigurationUri,
                  EFrameworkConfigurationLibrary)) {

        return false;
    }
    // Set class name to system class and configurable domains
    getSystemClass()->setName(getConstFrameworkConfiguration()->getSystemClassName());
    getConfigurableDomains()->setName(getConstFrameworkConfiguration()->getSystemClassName());

    // Get subsystem plugins elements
    _pSubsystemPlugins = static_cast<const CSubsystemPlugins *>(
        getConstFrameworkConfiguration()->findChild("SubsystemPlugins"));

    if (!_pSubsystemPlugins) {

        strError = "Parameter Framework Configuration: couldn't find SubsystemPlugins element";

        return false;
    }

    // Log tuning availability
    info() << "Tuning "
           << (getConstFrameworkConfiguration()->isTuningAllowed() ? "allowed" : "prohibited");

    return true;
}

bool CParameterMgr::loadSubsystems(std::string &error)
{
    LOG_CONTEXT("Loading subsystem plugins");

    // Load subsystems
    bool isSuccess =
        getSystemClass()->loadSubsystems(error, _pSubsystemPlugins, !_bFailOnMissingSubsystem);

    if (isSuccess) {
        info() << "All subsystem plugins successfully loaded";

        if (!error.empty()) {
            // Log missing subsystems as info
            info() << error;
        }
    } else {
        warning() << error;
    }
    return isSuccess;
}

bool CParameterMgr::loadStructure(string &strError)
{
    // Retrieve system to load structure to
    CSystemClass *pSystemClass = getSystemClass();

    LOG_CONTEXT("Loading " + pSystemClass->getName() + " system class structure");

    // Get structure description element
    const CFrameworkConfigurationLocation *pStructureDescriptionFileLocation =
        static_cast<const CFrameworkConfigurationLocation *>(
            getConstFrameworkConfiguration()->findChildOfKind("StructureDescriptionFileLocation"));

    if (!pStructureDescriptionFileLocation) {

        strError = "No StructureDescriptionFileLocation element found for SystemClass " +
                   pSystemClass->getName();

        return false;
    }

    // Parse Structure XML file
    CParameterAccessContext accessContext(strError);
    CXmlParameterSerializingContext parameterBuildContext(accessContext, strError);

    {
        // Get structure URI
        string structureUri =
            CXmlDocSource::mkUri(_xmlConfigurationUri, pStructureDescriptionFileLocation->getUri());

        LOG_CONTEXT("Importing system structure from file " + structureUri);

        _xmlDoc *doc = CXmlDocSource::mkXmlDoc(structureUri, true, true, parameterBuildContext);
        if (doc == NULL) {
            return false;
        }

        if (!xmlParse(parameterBuildContext, pSystemClass, doc, structureUri,
                      EParameterCreationLibrary)) {

            return false;
        }
    }

    // Initialize offsets
    pSystemClass->setOffset(0);

    // Initialize main blackboard's size
    _pMainParameterBlackboard->setSize(pSystemClass->getFootPrint());

    return true;
}

bool CParameterMgr::loadSettings(string &strError)
{
    string strLoadError;
    bool success = loadSettingsFromConfigFile(strLoadError);

    if (!success && !_bFailOnFailedSettingsLoad) {
        // Load can not fail, ie continue but log the load errors
        warning() << strLoadError;
        warning() << "Failed to load settings, continue without domains.";
        success = true;
    }

    if (!success) {
        // Propagate the litteral error only if the function fails
        strError = strLoadError;
        return false;
    }

    return true;
}

bool CParameterMgr::loadSettingsFromConfigFile(string &strError)
{
    LOG_CONTEXT("Loading settings");

    // Get settings configuration element
    const CFrameworkConfigurationGroup *pParameterConfigurationGroup =
        static_cast<const CFrameworkConfigurationGroup *>(
            getConstFrameworkConfiguration()->findChildOfKind("SettingsConfiguration"));

    if (!pParameterConfigurationGroup) {

        // No settings to load

        return true;
    }

    // Get configurable domains element
    const CFrameworkConfigurationLocation *pConfigurableDomainsFileLocation =
        static_cast<const CFrameworkConfigurationLocation *>(
            pParameterConfigurationGroup->findChildOfKind("ConfigurableDomainsFileLocation"));

    if (!pConfigurableDomainsFileLocation) {

        strError = "No ConfigurableDomainsFileLocation element found for SystemClass " +
                   getSystemClass()->getName();

        return false;
    }
    // Get destination root element
    CConfigurableDomains *pConfigurableDomains = getConfigurableDomains();

    // Get Xml configuration domains URI
    string configurationDomainsUri =
        CXmlDocSource::mkUri(_xmlConfigurationUri, pConfigurableDomainsFileLocation->getUri());

    // Parse configuration domains XML file
    CXmlDomainImportContext xmlDomainImportContext(strError, true, *getSystemClass());

    // Selection criteria definition for rule creation
    xmlDomainImportContext.setSelectionCriteriaDefinition(
        getConstSelectionCriteria()->getSelectionCriteriaDefinition());

    // Auto validation of configurations
    xmlDomainImportContext.setAutoValidationRequired(true);

    info() << "Importing configurable domains from file " << configurationDomainsUri
           << " with settings";

    _xmlDoc *doc =
        CXmlDocSource::mkXmlDoc(configurationDomainsUri, true, true, xmlDomainImportContext);
    if (doc == NULL) {
        return false;
    }

    return xmlParse(xmlDomainImportContext, pConfigurableDomains, doc, _xmlConfigurationUri,
                    EParameterConfigurationLibrary, true, "SystemClassName");
}

// XML parsing
bool CParameterMgr::xmlParse(CXmlElementSerializingContext &elementSerializingContext,
                             CElement *pRootElement, _xmlDoc *doc, const string &baseUri,
                             CParameterMgr::ElementLibrary eElementLibrary, bool replace,
                             const string &strNameAttributeName)
{
    // Init serializing context
    elementSerializingContext.set(_pElementLibrarySet->getElementLibrary(eElementLibrary), baseUri);

    CXmlDocSource docSource(doc, _bValidateSchemasOnStart, pRootElement->getXmlElementName(),
                            pRootElement->getName(), strNameAttributeName);

    docSource.setSchemaBaseUri(getSchemaUri());

    // Start clean
    auto clean = [replace, &pRootElement] {
        if (replace) {
            pRootElement->clean();
        }
    };
    clean();

    CXmlMemoryDocSink memorySink(pRootElement);

    if (!memorySink.process(docSource, elementSerializingContext)) {
        clean();
        return false;
    }

    return true;
}

// Init
bool CParameterMgr::init(string &strError)
{
    return base::init(strError);
}

// Selection criteria interface
CSelectionCriterionType *CParameterMgr::createSelectionCriterionType(bool bIsInclusive)
{
    // Propagate
    return getSelectionCriteria()->createSelectionCriterionType(bIsInclusive);
}

CSelectionCriterion *CParameterMgr::createSelectionCriterion(
    const string &strName, const CSelectionCriterionType *pSelectionCriterionType)
{
    // Propagate
    return getSelectionCriteria()->createSelectionCriterion(strName, pSelectionCriterionType,
                                                            _logger);
}

// Selection criterion retrieval
CSelectionCriterion *CParameterMgr::getSelectionCriterion(const string &strName)
{
    // Propagate
    return getSelectionCriteria()->getSelectionCriterion(strName);
}

// Configuration application
void CParameterMgr::applyConfigurations()
{
    LOG_CONTEXT("Configuration application request");

    // Lock state
    lock_guard<mutex> autoLock(getBlackboardMutex());

    if (!_bTuningModeIsOn) {

        // Apply configuration(s)
        doApplyConfigurations(false);
    } else {

        warning() << "Configurations were not applied because the TuningMode is on";
    }
}

const CConfigurableElement *CParameterMgr::getConfigurableElement(const string &strPath,
                                                                  string &strError) const
{
    CPathNavigator pathNavigator(strPath);

    // Nagivate through system class
    if (!pathNavigator.navigateThrough(getConstSystemClass()->getName(), strError)) {

        return NULL;
    }

    // Find element
    const CElement *pElement = getConstSystemClass()->findDescendant(pathNavigator);

    if (!pElement) {

        strError = "Path not found: " + strPath;

        return NULL;
    }

    // Check found element is a parameter
    const CConfigurableElement *pConfigurableElement =
        static_cast<const CConfigurableElement *>(pElement);

    return pConfigurableElement;
}

CConfigurableElement *CParameterMgr::getConfigurableElement(const string &strPath, string &strError)
{
    // Implement the mutable version by calling the const one and removing
    // the const from the result.
    const auto *constThis = this;
    return const_cast<CConfigurableElement *>(constThis->getConfigurableElement(strPath, strError));
}

// Dynamic parameter handling
CParameterHandle *CParameterMgr::createParameterHandle(const string &strPath, string &strError)
{
    CConfigurableElement *pConfigurableElement = getConfigurableElement(strPath, strError);

    if (!pConfigurableElement) {

        // Element not found
        strError = "Element not found: " + strPath;
        return NULL;
    }

    if (!pConfigurableElement->isParameter()) {

        // Element is not parameter
        strError = "Not a parameter: " + strPath;

        return NULL;
    }

    // Convert as parameter and return new handle
    return new CParameterHandle(static_cast<CBaseParameter &>(*pConfigurableElement), *this);
}

// Dynamic element handling
ElementHandle *CParameterMgr::createElementHandle(const std::string &path, std::string &error)
{
    CConfigurableElement *pConfigurableElement;

    if (path == "/") {
        // Attempt to access root configurable element
        pConfigurableElement = getSystemClass();
    } else {
        pConfigurableElement = getConfigurableElement(path, error);
    }

    if (!pConfigurableElement) {

        // Element not found
        error = "Element not found: " + path;
        return nullptr;
    }

    // The only reason why a heap object is returned instead of retuning by copy
    // is to inform the client of a failure through a nullptr.
    // It could be avoided (return by copy) with an
    //  - optional equivalent (see boost::optional or std::experimental::optional)
    //  - exception (but the api is noexcept)
    return new ElementHandle(*pConfigurableElement, *this);
}

void CParameterMgr::getSettingsAsBytes(const CConfigurableElement &element,
                                       std::vector<uint8_t> &settings) const
{
    // Not useful as the get can not fail,
    // but the current design forces all serialization and deserialization to
    // have an error out string
    std::string error;

    // Prepare parameter access context for main blackboard.
    // No need to handle output raw format and value space as Byte arrays are hexa formatted
    CParameterAccessContext parameterAccessContext(error);
    parameterAccessContext.setParameterBlackboard(_pMainParameterBlackboard);

    // Get the settings
    element.getSettingsAsBytes(settings, parameterAccessContext);
}

bool CParameterMgr::setSettingsAsBytes(const CConfigurableElement &element,
                                       const std::vector<uint8_t> &settings, std::string &error)
{
    // Prepare parameter access context for main blackboard.
    // Notes:
    //     - No need to handle output raw format and value space as Byte arrays are interpreted as
    //     raw formatted
    //     - No check is done as to the intgrity of the input data.
    //       This may lead to undetected out of range value assignment.
    //       Use this functionality with caution
    CParameterAccessContext parameterAccessContext(error);
    parameterAccessContext.setParameterBlackboard(_pMainParameterBlackboard);
    parameterAccessContext.setAutoSync(autoSyncOn());

    // Set the settings
    return element.setSettingsAsBytes(settings, parameterAccessContext);
}

void CParameterMgr::setFailureOnMissingSubsystem(bool bFail)
{
    _bFailOnMissingSubsystem = bFail;
}

bool CParameterMgr::getFailureOnMissingSubsystem() const
{
    return _bFailOnMissingSubsystem;
}

void CParameterMgr::setFailureOnFailedSettingsLoad(bool bFail)
{
    _bFailOnFailedSettingsLoad = bFail;
}

bool CParameterMgr::getFailureOnFailedSettingsLoad() const
{
    return _bFailOnFailedSettingsLoad;
}

const string &CParameterMgr::getSchemaUri() const
{
    return _schemaUri;
}

void CParameterMgr::setSchemaUri(const string &schemaUri)
{
    _schemaUri = schemaUri;
}

void CParameterMgr::setValidateSchemasOnStart(bool bValidate)
{
    _bValidateSchemasOnStart = bValidate;
}

bool CParameterMgr::getValidateSchemasOnStart() const
{
    return _bValidateSchemasOnStart;
}

/////////////////// Remote command parsers
/// Version
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::versionCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    // Show version
    strResult = getVersion();

    return CCommandHandler::ESucceeded;
}

/// Status
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::statusCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    // System class
    const CSystemClass *pSystemClass = getSystemClass();

    // Show status
    /// General section
    utility::appendTitle(strResult, "General:");
    // System class
    strResult += "System Class: ";
    strResult += pSystemClass->getName();
    strResult += "\n";

    // Tuning mode
    strResult += "Tuning Mode: ";
    strResult += tuningModeOn() ? "on" : "off";
    strResult += "\n";

    // Value space
    strResult += "Value Space: ";
    strResult += valueSpaceIsRaw() ? "raw" : "real";
    strResult += "\n";

    // Output raw format
    strResult += "Output Raw Format: ";
    strResult += outputRawFormatIsHex() ? "hex" : "dec";
    strResult += "\n";

    // Auto Sync
    strResult += "Auto Sync: ";
    strResult += autoSyncOn() ? "on" : "off";
    strResult += "\n";

    /// Subsystem list
    utility::appendTitle(strResult, "Subsystems:");
    string strSubsystemList;
    pSystemClass->listChildrenPaths(strSubsystemList);
    strResult += strSubsystemList;

    /// Last applied configurations
    utility::appendTitle(strResult, "Last Applied [Pending] Configurations:");
    string strLastAppliedConfigurations;
    getConfigurableDomains()->listLastAppliedConfigurations(strLastAppliedConfigurations);
    strResult += strLastAppliedConfigurations;

    /// Criteria states
    utility::appendTitle(strResult, "Selection Criteria:");
    list<string> lstrSelectionCriteria;
    getSelectionCriteria()->listSelectionCriteria(lstrSelectionCriteria, false, true);
    // Concatenate the criterion list as the command result
    strResult += utility::asString(lstrSelectionCriteria);

    return CCommandHandler::ESucceeded;
}

/// Tuning Mode
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setTuningModeCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    if (remoteCommand.getArgument(0) == "on") {

        if (setTuningMode(true, strResult)) {

            return CCommandHandler::EDone;
        }
    } else if (remoteCommand.getArgument(0) == "off") {

        if (setTuningMode(false, strResult)) {

            return CCommandHandler::EDone;
        }
    } else {
        // Show usage
        return CCommandHandler::EShowUsage;
    }
    return CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getTuningModeCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    strResult = tuningModeOn() ? "on" : "off";

    return CCommandHandler::ESucceeded;
}

/// Value Space
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setValueSpaceCommandProcess(
    const IRemoteCommand &remoteCommand, string & /*strResult*/)
{
    if (remoteCommand.getArgument(0) == "raw") {

        setValueSpace(true);

        return CCommandHandler::EDone;

    } else if (remoteCommand.getArgument(0) == "real") {

        setValueSpace(false);

        return CCommandHandler::EDone;

    } else {
        // Show usage
        return CCommandHandler::EShowUsage;
    }
    return CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getValueSpaceCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    strResult = valueSpaceIsRaw() ? "raw" : "real";

    return CCommandHandler::ESucceeded;
}

/// Output Raw Format
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setOutputRawFormatCommandProcess(
    const IRemoteCommand &remoteCommand, string & /*strResult*/)
{
    if (remoteCommand.getArgument(0) == "hex") {

        setOutputRawFormat(true);

        return CCommandHandler::EDone;

    } else if (remoteCommand.getArgument(0) == "dec") {

        setOutputRawFormat(false);

        return CCommandHandler::EDone;

    } else {
        // Show usage
        return CCommandHandler::EShowUsage;
    }
    return CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getOutputRawFormatCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    strResult = outputRawFormatIsHex() ? "hex" : "dec";

    return CCommandHandler::ESucceeded;
}

/// Sync
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setAutoSyncCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    if (remoteCommand.getArgument(0) == "on") {

        if (setAutoSync(true, strResult)) {

            return CCommandHandler::EDone;
        }
    } else if (remoteCommand.getArgument(0) == "off") {

        if (setAutoSync(false, strResult)) {

            return CCommandHandler::EDone;
        }
    } else {
        // Show usage
        return CCommandHandler::EShowUsage;
    }
    return CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getAutoSyncCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    strResult = autoSyncOn() ? "on" : "off";

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::syncCommandProcess(
    const IRemoteCommand &, string &strResult)
{
    return sync(strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
}

/// Criteria
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listCriteriaCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    if (remoteCommand.getArgumentCount() > 1) {

        return CCommandHandler::EShowUsage;
    }

    string strOutputFormat;

    // Look for optional arguments
    if (remoteCommand.getArgumentCount() == 1) {

        // Get requested format
        strOutputFormat = remoteCommand.getArgument(0);

        // Capitalize
        std::transform(strOutputFormat.begin(), strOutputFormat.end(), strOutputFormat.begin(),
                       ::toupper);

        if (strOutputFormat != "XML" && strOutputFormat != "CSV") {

            return CCommandHandler::EShowUsage;
        }
    }

    if (strOutputFormat == "XML") {
        // Get Root element where to export from
        const CSelectionCriteriaDefinition *pSelectionCriteriaDefinition =
            getConstSelectionCriteria()->getSelectionCriteriaDefinition();

        if (!exportElementToXMLString(pSelectionCriteriaDefinition, "SelectionCriteria",
                                      CXmlSerializingContext{strResult}, strResult)) {

            return CCommandHandler::EFailed;
        }

        // Succeeded
        return CCommandHandler::ESucceeded;
    } else {

        // Requested format will be either CSV or human readable based on strOutputFormat content
        bool bHumanReadable = strOutputFormat.empty();

        list<string> lstrResult;
        getSelectionCriteria()->listSelectionCriteria(lstrResult, true, bHumanReadable);

        // Concatenate the criterion list as the command result
        strResult += utility::asString(lstrResult);

        return CCommandHandler::ESucceeded;
    }
}

/// Domains
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainsCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    getConfigurableDomains()->listDomains(strResult);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::createDomainCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return createDomain(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone
                                                                 : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteDomainCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return deleteDomain(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone
                                                                 : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteAllDomainsCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    return deleteAllDomains(strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::renameDomainCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return renameDomain(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setSequenceAwarenessCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Set property
    bool bSequenceAware;

    if (remoteCommand.getArgument(1) == "true") {

        bSequenceAware = true;

    } else if (remoteCommand.getArgument(1) == "false") {

        bSequenceAware = false;

    } else {
        // Show usage
        return CCommandHandler::EShowUsage;
    }

    return setSequenceAwareness(remoteCommand.getArgument(0), bSequenceAware, strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getSequenceAwarenessCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Get property
    bool bSequenceAware;

    if (!getSequenceAwareness(remoteCommand.getArgument(0), bSequenceAware, strResult)) {

        return CCommandHandler::EFailed;
    }

    strResult = bSequenceAware ? "true" : "false";

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainElementsCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return getConfigurableDomains()->listDomainElements(remoteCommand.getArgument(0), strResult)
               ? CCommandHandler::ESucceeded
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::addElementCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return addConfigurableElementToDomain(remoteCommand.getArgument(0),
                                          remoteCommand.getArgument(1), strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::removeElementCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return removeConfigurableElementFromDomain(remoteCommand.getArgument(0),
                                               remoteCommand.getArgument(1), strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::splitDomainCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return split(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

/// Configurations
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConfigurationsCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return getConstConfigurableDomains()->listConfigurations(remoteCommand.getArgument(0),
                                                             strResult)
               ? CCommandHandler::ESucceeded
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpDomainsCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    // Dummy error context
    string strError;
    utility::ErrorContext errorContext(strError);

    // Dump
    strResult = getConstConfigurableDomains()->dumpContent(errorContext);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::createConfigurationCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return createConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
                               strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteConfigurationCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return deleteConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
                               strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::renameConfigurationCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return renameConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
                               remoteCommand.getArgument(2), strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::saveConfigurationCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return saveConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::restoreConfigurationCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    core::Results result;
    if (!restoreConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), result)) {
        // Concatenate the error list as the command result
        strResult = utility::asString(result);

        return CCommandHandler::EFailed;
    }
    return CCommandHandler::EDone;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setElementSequenceCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Build configurable element path list
    std::vector<string> astrNewElementSequence;

    for (size_t argument = 2; argument < remoteCommand.getArgumentCount(); argument++) {

        astrNewElementSequence.push_back(remoteCommand.getArgument(argument));
    }

    // Delegate to configurable domains
    return setElementSequence(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
                              astrNewElementSequence, strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSequenceCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Delegate to configurable domains
    return getConfigurableDomains()->getElementSequence(remoteCommand.getArgument(0),
                                                        remoteCommand.getArgument(1), strResult)
               ? CCommandHandler::ESucceeded
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setRuleCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Delegate to configurable domains
    return setApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
                              remoteCommand.packArguments(2, remoteCommand.getArgumentCount() - 2),
                              strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::clearRuleCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Delegate to configurable domains
    return clearApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
                                strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getRuleCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Delegate to configurable domains
    return getApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult)
               ? CCommandHandler::ESucceeded
               : CCommandHandler::EFailed;
}

/// Elements/Parameters
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listElementsCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    CElementLocator elementLocator(getSystemClass(), false);

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    if (!pLocatedElement) {

        // List from root folder

        // Return system class qualified name
        pLocatedElement = getSystemClass();
    }

    // Return sub-elements
    strResult += pLocatedElement->listQualifiedPaths(false);

    return CCommandHandler::ESucceeded;
}

/// Elements/Parameters
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listParametersCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    CElementLocator elementLocator(getSystemClass(), false);

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    if (!pLocatedElement) {

        // List from root folder

        // Return system class qualified name
        pLocatedElement = getSystemClass();
    }

    // Return sub-elements
    strResult += pLocatedElement->listQualifiedPaths(true);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementStructureXMLCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    // Use default access context for structure export
    CParameterAccessContext accessContext(strResult);
    if (!exportElementToXMLString(pLocatedElement, pLocatedElement->getXmlElementName(),
                                  CXmlParameterSerializingContext{accessContext, strResult},
                                  strResult)) {

        return CCommandHandler::EFailed;
    }

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementBytesCommandProcess(
    const IRemoteCommand &remoteCommand, std::string &strResult)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    const CConfigurableElement *pConfigurableElement =
        static_cast<CConfigurableElement *>(pLocatedElement);

    // Get the settings
    vector<uint8_t> bytes;
    getSettingsAsBytes(*pConfigurableElement, bytes);

    // Hexa formatting
    std::ostringstream ostream;
    ostream << std::hex << std::setfill('0');

    // Format bytes
    for (auto byte : bytes) {

        // Convert to an int in order to avoid the "char" overload that would
        // print characters instead of numbers.
        ostream << "0x" << std::setw(2) << int{byte} << " ";
    }

    strResult = ostream.str();
    if (not strResult.empty()) {
        // Remove the trailing space
        strResult.pop_back();
    }

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setElementBytesCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Check tuning mode
    if (!checkTuningModeOn(strResult)) {

        return CCommandHandler::EFailed;
    }

    // Retrieve configurable element
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    const CConfigurableElement *pConfigurableElement =
        static_cast<CConfigurableElement *>(pLocatedElement);

    // Convert input data to binary
    vector<uint8_t> bytes;

    auto first = remoteCommand.getArguments().cbegin() + 1;
    auto last = remoteCommand.getArguments().cend();

    try {
        std::transform(first, last, begin(bytes), [](decltype(*first) input) {
            uint8_t byte;

            if (!convertTo(input, byte)) {
                throw std::domain_error("Some values out of byte range");
            }

            return byte;
        });
    } catch (const std::domain_error &e) {
        strResult = e.what();

        return CCommandHandler::EFailed;
    }

    // Set the settings
    if (!setSettingsAsBytes(*pConfigurableElement, bytes, strResult)) {

        return CCommandHandler::EFailed;
    }

    return CCommandHandler::EDone;
}

bool CParameterMgr::getSettingsAsXML(const CConfigurableElement *configurableElement,
                                     string &result) const
{
    string error;
    CConfigurationAccessContext configContext(error, _pMainParameterBlackboard, _bValueSpaceIsRaw,
                                              _bOutputRawFormatIsHex, true);

    CXmlParameterSerializingContext xmlParameterContext(configContext, error);

    // Use a doc source by loading data from instantiated Configurable Domains
    CXmlMemoryDocSource memorySource(configurableElement, false,
                                     configurableElement->getXmlElementName());

    // Use a doc sink that write the doc data in a string
    ostringstream output;
    CXmlStreamDocSink streamSink(output);

    if (not streamSink.process(memorySource, xmlParameterContext)) {
        result = error;
        return false;
    }
    result = output.str();
    return true;
}

bool CParameterMgr::setSettingsAsXML(CConfigurableElement *configurableElement,
                                     const string &settings, string &error)
{
    CConfigurationAccessContext configContext(error, _pMainParameterBlackboard, _bValueSpaceIsRaw,
                                              _bOutputRawFormatIsHex, false);

    CXmlParameterSerializingContext xmlParameterContext(configContext, error);

    // It doesn't make sense to resolve XIncludes on an imported file because
    // we can't reliably decide of a "base url"
    _xmlDoc *doc = CXmlDocSource::mkXmlDoc(settings, false, false, xmlParameterContext);
    if (doc == nullptr) {
        return false;
    }
    if (not xmlParse(xmlParameterContext, configurableElement, doc, "",
                     EParameterConfigurationLibrary, false)) {
        return false;
    }
    if (_bAutoSyncOn) {
        CSyncerSet syncerSet;
        static_cast<CConfigurableElement *>(configurableElement)->fillSyncerSet(syncerSet);
        core::Results errors;
        if (not syncerSet.sync(*_pMainParameterBlackboard, false, &errors)) {
            error = utility::asString(errors);

            return false;
        }
    }
    return true;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementXMLCommandProcess(
    const IRemoteCommand &remoteCommand, string &result)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *locatedElement = nullptr;

    if (not elementLocator.locate(remoteCommand.getArgument(0), &locatedElement, result)) {

        return CCommandHandler::EFailed;
    }

    if (not getSettingsAsXML(static_cast<CConfigurableElement *>(locatedElement), result)) {
        return CCommandHandler::EFailed;
    }
    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setElementXMLCommandProcess(
    const IRemoteCommand &remoteCommand, string &result)
{
    if (!checkTuningModeOn(result)) {

        return CCommandHandler::EFailed;
    }

    CElementLocator elementLocator(getSystemClass());

    CElement *locatedElement = nullptr;

    if (not elementLocator.locate(remoteCommand.getArgument(0), &locatedElement, result)) {

        return CCommandHandler::EFailed;
    }
    if (not setSettingsAsXML(static_cast<CConfigurableElement *>(locatedElement),
                             remoteCommand.getArgument(1), result)) {
        return CCommandHandler::EFailed;
    }
    return CCommandHandler::EDone;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpElementCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    string strError;

    CParameterAccessContext parameterAccessContext(strError, _pMainParameterBlackboard,
                                                   _bValueSpaceIsRaw, _bOutputRawFormatIsHex);

    // Dump elements
    strResult = pLocatedElement->dumpContent(parameterAccessContext);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSizeCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    // Converted to actual sizable element
    const CConfigurableElement *pConfigurableElement =
        static_cast<const CConfigurableElement *>(pLocatedElement);

    // Get size as string
    strResult = pConfigurableElement->getFootprintAsString();

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showPropertiesCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    // Convert element
    const CConfigurableElement *pConfigurableElement =
        static_cast<const CConfigurableElement *>(pLocatedElement);

    // Return element properties
    pConfigurableElement->showProperties(strResult);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getParameterCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    string strValue;

    if (!accessParameterValue(remoteCommand.getArgument(0), strValue, false, strResult)) {

        return CCommandHandler::EFailed;
    }
    // Succeeded
    strResult = strValue;

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setParameterCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    // Get value to set
    string strValue = remoteCommand.packArguments(1, remoteCommand.getArgumentCount() - 1);

    return accessParameterValue(remoteCommand.getArgument(0), strValue, true, strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listBelongingDomainsCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    // Convert element
    const CConfigurableElement *pConfigurableElement =
        static_cast<const CConfigurableElement *>(pLocatedElement);

    // Return element belonging domains
    pConfigurableElement->listBelongingDomains(strResult);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedDomainsCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {

        return CCommandHandler::EFailed;
    }

    // Convert element
    const CConfigurableElement *pConfigurableElement =
        static_cast<const CConfigurableElement *>(pLocatedElement);

    // Return element belonging domains
    pConfigurableElement->listAssociatedDomains(strResult);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedElementsCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    getConfigurableDomains()->listAssociatedElements(strResult);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConflictingElementsCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    getConfigurableDomains()->listConflictingElements(strResult);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listRogueElementsCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    getSystemClass()->listRogueElements(strResult);

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::
    getConfigurationParameterCommandProcess(const IRemoteCommand &remoteCommand, string &strResult)
{
    string strOutputValue;
    string strError;

    if (!accessConfigurationValue(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
                                  remoteCommand.getArgument(2), strOutputValue, false, strError)) {

        strResult = strError;
        return CCommandHandler::EFailed;
    }
    // Succeeded
    strResult = strOutputValue;

    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::
    setConfigurationParameterCommandProcess(const IRemoteCommand &remoteCommand, string &strResult)
{
    // Get value to set
    string strValue = remoteCommand.packArguments(3, remoteCommand.getArgumentCount() - 3);

    bool bSuccess =
        accessConfigurationValue(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
                                 remoteCommand.getArgument(2), strValue, true, strResult);

    return bSuccess ? CCommandHandler::EDone : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showMappingCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    if (!getParameterMapping(remoteCommand.getArgument(0), strResult)) {

        return CCommandHandler::EFailed;
    }

    return CCommandHandler::ESucceeded;
}

/// Settings Import/Export
CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::exportDomainsXMLCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    string strFileName = remoteCommand.getArgument(0);
    return exportDomainsXml(strFileName, false, true, strResult) ? CCommandHandler::EDone
                                                                 : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importDomainsXMLCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return importDomainsXml(remoteCommand.getArgument(0), false, true, strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::
    exportDomainsWithSettingsXMLCommandProcess(const IRemoteCommand &remoteCommand,
                                               string &strResult)
{
    string strFileName = remoteCommand.getArgument(0);
    return exportDomainsXml(strFileName, true, true, strResult) ? CCommandHandler::EDone
                                                                : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::
    exportDomainWithSettingsXMLCommandProcess(const IRemoteCommand &remoteCommand, string &result)
{
    string domainName = remoteCommand.getArgument(0);
    string fileName = remoteCommand.getArgument(1);
    return exportSingleDomainXml(fileName, domainName, true, true, result)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::
    importDomainsWithSettingsXMLCommandProcess(const IRemoteCommand &remoteCommand,
                                               string &strResult)
{
    return importDomainsXml(remoteCommand.getArgument(0), true, true, strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::
    importDomainWithSettingsXMLCommandProcess(const IRemoteCommand &remoteCommand,
                                              string &strResult)
{
    bool bOverwrite = false;

    // Look for optional arguments
    if (remoteCommand.getArgumentCount() > 1) {

        if (remoteCommand.getArgument(1) == "overwrite") {

            bOverwrite = true;
        } else {
            // Show usage
            return CCommandHandler::EShowUsage;
        }
    }

    return importSingleDomainXml(remoteCommand.getArgument(0), bOverwrite, true, true, strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::
    getDomainsWithSettingsXMLCommandProcess(const IRemoteCommand & /*command*/, string &strResult)
{
    if (!exportDomainsXml(strResult, true, false, strResult)) {

        return CCommandHandler::EFailed;
    }
    // Succeeded
    return CCommandHandler::ESucceeded;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getDomainWithSettingsXMLCommandProcess(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    string strDomainName = remoteCommand.getArgument(0);

    return exportSingleDomainXml(strResult, strDomainName, true, false, strResult)
               ? CCommandHandler::ESucceeded
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::
    setDomainsWithSettingsXMLCommandProcess(const IRemoteCommand &remoteCommand, string &strResult)
{
    return importDomainsXml(remoteCommand.getArgument(0), true, false, strResult)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setDomainWithSettingsXMLCommandProcess(
    const IRemoteCommand &remoteCommand, string &result)
{
    bool overwrite = false;

    if (remoteCommand.getArgumentCount() > 1) {

        if (remoteCommand.getArgument(1) == "overwrite") {

            overwrite = true;
        } else {
            // Show usage
            return CCommandHandler::EShowUsage;
        }
    }

    return importSingleDomainXml(remoteCommand.getArgument(0), overwrite, true, false, result)
               ? CCommandHandler::EDone
               : CCommandHandler::EFailed;
}

CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getSystemClassXMLCommandProcess(
    const IRemoteCommand & /*command*/, string &strResult)
{
    // Get Root element where to export from
    const CSystemClass *pSystemClass = getSystemClass();

    // Use default access context for structure export
    CParameterAccessContext accessContext(strResult);
    if (!exportElementToXMLString(pSystemClass, pSystemClass->getXmlElementName(),
                                  CXmlParameterSerializingContext{accessContext, strResult},
                                  strResult)) {
        return CCommandHandler::EFailed;
    }
    // Succeeded
    return CCommandHandler::ESucceeded;
}

// User set/get parameters in main BlackBoard
bool CParameterMgr::accessParameterValue(const string &strPath, string &strValue, bool bSet,
                                         string &strError)
{
    // Forbid write access when not in TuningMode
    if (bSet && !checkTuningModeOn(strError)) {

        return false;
    }

    // Define context
    CParameterAccessContext parameterAccessContext(strError, _pMainParameterBlackboard,
                                                   _bValueSpaceIsRaw, _bOutputRawFormatIsHex);

    // Activate the auto synchronization with the hardware
    if (bSet) {

        parameterAccessContext.setAutoSync(_bAutoSyncOn);
    }

    return accessValue(parameterAccessContext, strPath, strValue, bSet, strError);
}

// User get parameter mapping
bool CParameterMgr::getParameterMapping(const string &strPath, string &strResult) const
{
    // Get the ConfigurableElement corresponding to strPath
    const CConfigurableElement *pConfigurableElement = getConfigurableElement(strPath, strResult);
    if (!pConfigurableElement) {

        return false;
    }

    // Find the list of the ancestors of the current ConfigurableElement that have a mapping
    auto configurableElementPath = pConfigurableElement->getConfigurableElementContext();

    // Get the Subsystem containing the ConfigurableElement
    const CSubsystem *pSubsystem = pConfigurableElement->getBelongingSubsystem();
    if (!pSubsystem) {

        strResult = "Unable to find the Subsystem containing the parameter";
        return false;
    }

    // Fetch the mapping corresponding to the ConfigurableElement
    strResult = pSubsystem->getMapping(configurableElementPath);

    return true;
}

// User set/get parameters in specific Configuration BlackBoard
bool CParameterMgr::accessConfigurationValue(const string &strDomain,
                                             const string &strConfiguration, const string &strPath,
                                             string &strValue, bool bSet, string &strError)
{
    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(strPath, &pLocatedElement, strError)) {

        return false;
    }

    // Convert element
    const CConfigurableElement *pConfigurableElement =
        static_cast<const CConfigurableElement *>(pLocatedElement);

    // Get the Configuration blackboard and the Base Offset of the configurable element in this
    // blackboard
    size_t baseOffset;
    bool bIsLastApplied;

    CParameterBlackboard *pConfigurationBlackboard = NULL;

    {
        pConfigurationBlackboard = getConstConfigurableDomains()->findConfigurationBlackboard(
            strDomain, strConfiguration, pConfigurableElement, baseOffset, bIsLastApplied,
            strError);
        if (!pConfigurationBlackboard) {

            warning() << "Fail: " << strError;
            return false;
        }
    }

    info() << "Element " << strPath << " in Domain " << strDomain
           << ", offset: " << pConfigurableElement->getOffset() << ", base offset: " << baseOffset;

    /// Update the Configuration Blackboard

    // Define Configuration context using Base Offset and keep Auto Sync off to prevent access to HW
    CParameterAccessContext parameterAccessContext(
        strError, pConfigurationBlackboard, _bValueSpaceIsRaw, _bOutputRawFormatIsHex, baseOffset);

    // Deactivate the auto synchronization with the hardware during the Configuration Blackboard
    // access (only Main Blackboard shall be synchronized, Configurations Blackboards are copied
    // into the Main Blackboard each time a configuration is restored but they are not synchronized
    // directly).
    if (bSet) {

        parameterAccessContext.setAutoSync(false);
    }

    // Access Value in the Configuration Blackboard
    if (!accessValue(parameterAccessContext, strPath, strValue, bSet, strError)) {

        return false;
    }

    /// If the Configuration is the last one applied, update the Main Blackboard as well

    if (bIsLastApplied) {

        // Define Main context
        parameterAccessContext.setParameterBlackboard(_pMainParameterBlackboard);

        // Activate the auto synchronization with the hardware
        if (bSet) {

            parameterAccessContext.setAutoSync(_bAutoSyncOn);
        }

        // Access Value in the Main Blackboard
        return accessValue(parameterAccessContext, strPath, strValue, bSet, strError);
    }

    return true;
}

// User set/get parameters
bool CParameterMgr::accessValue(CParameterAccessContext &parameterAccessContext,
                                const string &strPath, string &strValue, bool bSet,
                                string &strError)
{
    // Lock state
    lock_guard<mutex> autoLock(getBlackboardMutex());

    CPathNavigator pathNavigator(strPath);

    // Nagivate through system class
    if (!pathNavigator.navigateThrough(getConstSystemClass()->getName(), strError)) {

        parameterAccessContext.setError(strError);

        return false;
    }

    // Do the get
    return getConstSystemClass()->accessValue(pathNavigator, strValue, bSet,
                                              parameterAccessContext);
}

// Tuning mode
bool CParameterMgr::setTuningMode(bool bOn, string &strError)
{
    if (bOn == tuningModeOn()) {
        strError = "Tuning mode is already in the state requested";
        return false;
    }
    // Tuning allowed?
    if (bOn && !getConstFrameworkConfiguration()->isTuningAllowed()) {

        strError = "Tuning prohibited";

        return false;
    }
    // Lock state
    lock_guard<mutex> autoLock(getBlackboardMutex());

    // Warn domains about exiting tuning mode
    if (!bOn) {

        // Ensure application of currently selected configurations
        // Force-apply configurations
        doApplyConfigurations(true);
    }

    // Store
    _bTuningModeIsOn = bOn;

    return true;
}

bool CParameterMgr::tuningModeOn() const
{
    return _bTuningModeIsOn;
}

// Current value space for user set/get value interpretation
void CParameterMgr::setValueSpace(bool bIsRaw)
{
    _bValueSpaceIsRaw = bIsRaw;
}

bool CParameterMgr::valueSpaceIsRaw()
{
    return _bValueSpaceIsRaw;
}

// Current Output Raw Format for user get value interpretation
void CParameterMgr::setOutputRawFormat(bool bIsHex)
{
    _bOutputRawFormatIsHex = bIsHex;
}

bool CParameterMgr::outputRawFormatIsHex()
{
    return _bOutputRawFormatIsHex;
}

/// Sync
// Automatic hardware synchronization control (during tuning session)
bool CParameterMgr::setAutoSync(bool bAutoSyncOn, string &strError)
{
    // Warn domains about turning auto sync back on
    if (bAutoSyncOn && !_bAutoSyncOn) {

        // Do the synchronization at system class level (could be optimized by keeping track of all
        // modified parameters)
        if (!sync(strError)) {

            return false;
        }
    }

    // Set Auto sync
    _bAutoSyncOn = bAutoSyncOn;

    return true;
}

bool CParameterMgr::autoSyncOn() const
{
    return _bAutoSyncOn;
}

// Manual hardware synchronization control (during tuning session)
bool CParameterMgr::sync(string &strError)
{
    // Warn domains about turning auto sync back on
    if (_bAutoSyncOn) {

        strError = "Feature unavailable when Auto Sync is on";

        return false;
    }

    // Get syncer set
    CSyncerSet syncerSet;
    // ... from system class
    getConstSystemClass()->fillSyncerSet(syncerSet);

    // Sync
    core::Results error;
    if (!syncerSet.sync(*_pMainParameterBlackboard, false, &error)) {

        strError = utility::asString(error);
        return false;
    };

    return true;
}

// Configuration/Domains handling
bool CParameterMgr::createDomain(const string &strName, string &strError)
{
    LOG_CONTEXT("Creating configurable domain " + strName);
    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        return false;
    }

    // Delegate to configurable domains
    return logResult(getConfigurableDomains()->createDomain(strName, strError), strError);
}

bool CParameterMgr::deleteDomain(const string &strName, string &strError)
{
    LOG_CONTEXT("Deleting configurable domain '" + strName + "'");

    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        warning() << "Fail: " << strError;
        return false;
    }

    // Delegate to configurable domains
    return logResult(getConfigurableDomains()->deleteDomain(strName, strError), strError);
}

bool CParameterMgr::renameDomain(const string &strName, const string &strNewName, string &strError)
{
    LOG_CONTEXT("Renaming configurable domain '" + strName + "' to '" + strNewName + "'");

    // Delegate to configurable domains
    return logResult(getConfigurableDomains()->renameDomain(strName, strNewName, strError),
                     strError);
}

bool CParameterMgr::deleteAllDomains(string &strError)
{
    LOG_CONTEXT("Deleting all configurable domains");

    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        warning() << "Fail: " << strError;
        return false;
    }

    // Delegate to configurable domains
    getConfigurableDomains()->deleteAllDomains();

    info() << "Success";
    return true;
}

bool CParameterMgr::setSequenceAwareness(const string &strName, bool bSequenceAware,
                                         string &strResult)
{
    LOG_CONTEXT("Making domain '" + strName + "' sequence " +
                (bSequenceAware ? "aware" : "unaware"));
    // Check tuning mode
    if (!checkTuningModeOn(strResult)) {

        warning() << "Fail: " << strResult;
        return false;
    }

    return logResult(
        getConfigurableDomains()->setSequenceAwareness(strName, bSequenceAware, strResult),
        strResult);
}

bool CParameterMgr::getSequenceAwareness(const string &strName, bool &bSequenceAware,
                                         string &strResult)
{
    return getConfigurableDomains()->getSequenceAwareness(strName, bSequenceAware, strResult);
}

bool CParameterMgr::createConfiguration(const string &strDomain, const string &strConfiguration,
                                        string &strError)
{
    LOG_CONTEXT("Creating domain configuration '" + strConfiguration + "' into domain '" +
                strDomain + "'");
    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        warning() << "Fail: " << strError;
        return false;
    }

    // Delegate to configurable domains
    return logResult(getConfigurableDomains()->createConfiguration(
                         strDomain, strConfiguration, _pMainParameterBlackboard, strError),
                     strError);
}
bool CParameterMgr::renameConfiguration(const string &strDomain, const string &strConfiguration,
                                        const string &strNewConfiguration, string &strError)
{
    LOG_CONTEXT("Renaming domain '" + strDomain + "''s configuration '" + strConfiguration +
                "' to '" + strNewConfiguration + "'");

    return logResult(getConfigurableDomains()->renameConfiguration(strDomain, strConfiguration,
                                                                   strNewConfiguration, strError),
                     strError);
}

bool CParameterMgr::deleteConfiguration(const string &strDomain, const string &strConfiguration,
                                        string &strError)
{
    LOG_CONTEXT("Deleting configuration '" + strConfiguration + "' from domain '" + strDomain +
                "'");

    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        warning() << "Fail:" << strError;
        return false;
    }

    // Delegate to configurable domains
    return logResult(
        getConfigurableDomains()->deleteConfiguration(strDomain, strConfiguration, strError),
        strError);
}

bool CParameterMgr::restoreConfiguration(const string &strDomain, const string &strConfiguration,
                                         core::Results &errors)
{
    string strError;
    LOG_CONTEXT("Restoring domain '" + strDomain + "''s configuration '" + strConfiguration +
                "' to parameter blackboard");
    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        errors.push_back(strError);
        warning() << "Fail:" << strError;
        return false;
    }

    // Delegate to configurable domains
    return logResult(
        getConstConfigurableDomains()->restoreConfiguration(
            strDomain, strConfiguration, _pMainParameterBlackboard, _bAutoSyncOn, errors),
        strError);
}

bool CParameterMgr::saveConfiguration(const string &strDomain, const string &strConfiguration,
                                      string &strError)
{
    LOG_CONTEXT("Saving domain '" + strDomain + "' configuration '" + strConfiguration +
                "' from parameter blackboard");
    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        warning() << "Fail:" << strError;
        return false;
    }

    // Delegate to configurable domains
    return logResult(getConfigurableDomains()->saveConfiguration(
                         strDomain, strConfiguration, _pMainParameterBlackboard, strError),
                     strError);
}

// Configurable element - domain association
bool CParameterMgr::addConfigurableElementToDomain(const string &strDomain,
                                                   const string &strConfigurableElementPath,
                                                   string &strError)
{
    LOG_CONTEXT("Adding configurable element '" + strConfigurableElementPath + "' to domain '" +
                strDomain + "'");
    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        warning() << "Fail: " << strError;
        return false;
    }

    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(strConfigurableElementPath, &pLocatedElement, strError)) {

        warning() << "Fail: " << strError;
        return false;
    }

    // Convert element
    CConfigurableElement *pConfigurableElement =
        static_cast<CConfigurableElement *>(pLocatedElement);

    // Delegate
    core::Results infos;
    bool isSuccess = getConfigurableDomains()->addConfigurableElementToDomain(
        strDomain, pConfigurableElement, _pMainParameterBlackboard, infos);

    if (isSuccess) {
        info() << infos;
    } else {
        warning() << infos;
    }

    strError = utility::asString(infos);
    return isSuccess;
}

bool CParameterMgr::removeConfigurableElementFromDomain(const string &strDomain,
                                                        const string &strConfigurableElementPath,
                                                        string &strError)
{
    LOG_CONTEXT("Removing configurable element '" + strConfigurableElementPath + "' from domain '" +
                strDomain + "'");

    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        warning() << "Fail:" << strError;
        return false;
    }

    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(strConfigurableElementPath, &pLocatedElement, strError)) {

        warning() << "Fail:" << strError;
        return false;
    }

    // Convert element
    CConfigurableElement *pConfigurableElement =
        static_cast<CConfigurableElement *>(pLocatedElement);

    // Delegate
    return logResult(getConfigurableDomains()->removeConfigurableElementFromDomain(
                         strDomain, pConfigurableElement, strError),
                     strError);
}

bool CParameterMgr::split(const string &strDomain, const string &strConfigurableElementPath,
                          string &strError)
{
    LOG_CONTEXT("Splitting configurable element '" + strConfigurableElementPath + "' domain '" +
                strDomain + "'");
    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        warning() << "Fail:" << strError;
        return false;
    }

    CElementLocator elementLocator(getSystemClass());

    CElement *pLocatedElement = NULL;

    if (!elementLocator.locate(strConfigurableElementPath, &pLocatedElement, strError)) {

        warning() << "Fail: " << strError;
        return false;
    }

    // Convert element
    CConfigurableElement *pConfigurableElement =
        static_cast<CConfigurableElement *>(pLocatedElement);

    // Delegate
    core::Results infos;
    bool isSuccess = getConfigurableDomains()->split(strDomain, pConfigurableElement, infos);

    if (isSuccess) {
        info() << infos;
    } else {
        warning() << infos;
    }

    strError = utility::asString(infos);
    return isSuccess;
}

bool CParameterMgr::setElementSequence(const string &strDomain, const string &strConfiguration,
                                       const std::vector<string> &astrNewElementSequence,
                                       string &strError)
{
    // Check tuning mode
    if (!checkTuningModeOn(strError)) {

        return false;
    }

    return getConfigurableDomains()->setElementSequence(strDomain, strConfiguration,
                                                        astrNewElementSequence, strError);
}

bool CParameterMgr::getApplicationRule(const string &strDomain, const string &strConfiguration,
                                       string &strResult)
{
    return getConfigurableDomains()->getApplicationRule(strDomain, strConfiguration, strResult);
}

bool CParameterMgr::setApplicationRule(const string &strDomain, const string &strConfiguration,
                                       const string &strApplicationRule, string &strError)
{
    return getConfigurableDomains()->setApplicationRule(
        strDomain, strConfiguration, strApplicationRule,
        getConstSelectionCriteria()->getSelectionCriteriaDefinition(), strError);
}

bool CParameterMgr::clearApplicationRule(const string &strDomain, const string &strConfiguration,
                                         string &strError)
{
    return getConfigurableDomains()->clearApplicationRule(strDomain, strConfiguration, strError);
}

bool CParameterMgr::importDomainsXml(const string &xmlSource, bool withSettings, bool fromFile,
                                     string &errorMsg)
{
    // Check tuning mode
    if (!checkTuningModeOn(errorMsg)) {

        return false;
    }

    LOG_CONTEXT("Importing domains from " +
                (fromFile ? ("\"" + xmlSource + "\"") : "a user-provided buffer"));

    // Root element
    CConfigurableDomains *pConfigurableDomains = getConfigurableDomains();

    bool importSuccess = wrapLegacyXmlImport(xmlSource, fromFile, withSettings,
                                             *pConfigurableDomains, "SystemClassName", errorMsg);

    if (importSuccess) {

        // Validate domains after XML import
        pConfigurableDomains->validate(_pMainParameterBlackboard);
    }

    return importSuccess;
}

bool CParameterMgr::importSingleDomainXml(const string &xmlSource, bool overwrite,
                                          bool withSettings, bool fromFile, string &errorMsg)
{
    if (!checkTuningModeOn(errorMsg)) {

        return false;
    }

    LOG_CONTEXT("Importing a single domain from " +
                (fromFile ? ('"' + xmlSource + '"') : "a user-provided buffer"));

    // We initialize the domain with an empty name but since we have set the isDomainStandalone
    // context, the name will be retrieved during de-serialization
    auto standaloneDomain = utility::make_unique<CConfigurableDomain>();

    if (!wrapLegacyXmlImport(xmlSource, fromFile, withSettings, *standaloneDomain, "", errorMsg)) {
        return false;
    }

    if (!getConfigurableDomains()->addDomain(*standaloneDomain, overwrite, errorMsg)) {
        return false;
    }

    // ownership has been transfered to the ConfigurableDomains object
    standaloneDomain.release();
    return true;
}

bool CParameterMgr::wrapLegacyXmlImport(const string &xmlSource, bool fromFile, bool withSettings,
                                        CElement &element, const string &nameAttributeName,
                                        string &errorMsg)
{
    CXmlDomainImportContext xmlDomainImportContext(errorMsg, withSettings, *getSystemClass());

    // Selection criteria definition for rule creation
    xmlDomainImportContext.setSelectionCriteriaDefinition(
        getConstSelectionCriteria()->getSelectionCriteriaDefinition());

    // It doesn't make sense to resolve XIncludes on an imported file because
    // we can't reliably decide of a "base url"
    _xmlDoc *doc = CXmlDocSource::mkXmlDoc(xmlSource, fromFile, false, xmlDomainImportContext);
    if (doc == NULL) {
        return false;
    }

    return xmlParse(xmlDomainImportContext, &element, doc, "", EParameterConfigurationLibrary, true,
                    nameAttributeName);
}

bool CParameterMgr::serializeElement(std::ostream &output,
                                     CXmlSerializingContext &xmlSerializingContext,
                                     const CElement &element) const
{
    if (!output.good()) {
        xmlSerializingContext.setError("Can't write XML: the output is in a bad state.");
        return false;
    }

    // Use a doc source by loading data from instantiated Configurable Domains
    CXmlMemoryDocSource memorySource(&element, _bValidateSchemasOnStart,
                                     element.getXmlElementName(), "parameter-framework",
                                     getVersion());

    // Use a doc sink to write the doc data in a stream
    CXmlStreamDocSink sink(output);

    bool processSuccess = sink.process(memorySource, xmlSerializingContext);

    return processSuccess;
}

bool CParameterMgr::exportDomainsXml(string &xmlDest, bool withSettings, bool toFile,
                                     string &errorMsg) const
{
    LOG_CONTEXT("Exporting domains to " +
                (toFile ? ('"' + xmlDest + '"') : "a user-provided buffer"));

    const CConfigurableDomains *configurableDomains = getConstConfigurableDomains();

    return wrapLegacyXmlExport(xmlDest, toFile, withSettings, *configurableDomains, errorMsg);
}

bool CParameterMgr::exportSingleDomainXml(string &xmlDest, const string &domainName,
                                          bool withSettings, bool toFile, string &errorMsg) const
{
    LOG_CONTEXT("Exporting single domain '" + domainName + "' to " +
                (toFile ? ('"' + xmlDest + '"') : "a user-provided buffer"));

    // Element to be serialized
    const CConfigurableDomain *requestedDomain =
        getConstConfigurableDomains()->findConfigurableDomain(domainName, errorMsg);

    if (requestedDomain == NULL) {
        return false;
    }

    return wrapLegacyXmlExport(xmlDest, toFile, withSettings, *requestedDomain, errorMsg);
}

bool CParameterMgr::wrapLegacyXmlExport(string &xmlDest, bool toFile, bool withSettings,
                                        const CElement &element, string &errorMsg) const
{
    CXmlDomainExportContext context(errorMsg, withSettings, _bValueSpaceIsRaw,
                                    _bOutputRawFormatIsHex);

    if (toFile) {
        return wrapLegacyXmlExportToFile(xmlDest, element, context);
    } else {
        return wrapLegacyXmlExportToString(xmlDest, element, context);
    }
}

bool CParameterMgr::wrapLegacyXmlExportToFile(string &xmlDest, const CElement &element,
                                              CXmlDomainExportContext &context) const
{
    try {
        std::ofstream output;
        // Force stream to throw instead of using fail/bad bit
        // in order to retreive an error message.
        output.exceptions(~std::ifstream::goodbit);

        output.open(xmlDest.c_str());
        bool status = serializeElement(output, context, element);
        output.close(); // Explicit close to detect errors

        return status;

    } catch (std::ofstream::failure &e) {
        context.setError("Failed to open \"" + xmlDest + "\" for writing: " + e.what());
        return false;
    }
}

bool CParameterMgr::wrapLegacyXmlExportToString(string &xmlDest, const CElement &element,
                                                CXmlDomainExportContext &context) const
{
    std::ostringstream output;

    if (!serializeElement(output, context, element)) {
        return false;
    }

    xmlDest = output.str();

    return true;
}

// For tuning, check we're in tuning mode
bool CParameterMgr::checkTuningModeOn(string &strError) const
{
    // Tuning Mode on?
    if (!_bTuningModeIsOn) {

        strError = "Tuning Mode must be on";

        return false;
    }
    return true;
}

// Tuning mutex dynamic parameter handling
std::mutex &CParameterMgr::getBlackboardMutex()
{
    return _blackboardMutex;
}

// Blackboard reference (dynamic parameter handling)
CParameterBlackboard *CParameterMgr::getParameterBlackboard()
{
    return _pMainParameterBlackboard;
}

// Dynamic creation library feeding
void CParameterMgr::feedElementLibraries()
{
    // Global Configuration handling
    CElementLibrary *pFrameworkConfigurationLibrary = new CElementLibrary;

    pFrameworkConfigurationLibrary->addElementBuilder(
        "ParameterFrameworkConfiguration",
        new TElementBuilderTemplate<CParameterFrameworkConfiguration>());
    pFrameworkConfigurationLibrary->addElementBuilder(
        "SubsystemPlugins", new TKindElementBuilderTemplate<CSubsystemPlugins>());
    pFrameworkConfigurationLibrary->addElementBuilder(
        "Location", new TKindElementBuilderTemplate<CPluginLocation>());
    pFrameworkConfigurationLibrary->addElementBuilder(
        "StructureDescriptionFileLocation",
        new TKindElementBuilderTemplate<CFrameworkConfigurationLocation>());
    pFrameworkConfigurationLibrary->addElementBuilder(
        "SettingsConfiguration", new TKindElementBuilderTemplate<CFrameworkConfigurationGroup>());
    pFrameworkConfigurationLibrary->addElementBuilder(
        "ConfigurableDomainsFileLocation",
        new TKindElementBuilderTemplate<CFrameworkConfigurationLocation>());

    _pElementLibrarySet->addElementLibrary(pFrameworkConfigurationLibrary);

    // Parameter creation
    CElementLibrary *pParameterCreationLibrary = new CElementLibrary;

    pParameterCreationLibrary->addElementBuilder(
        "Subsystem", new CSubsystemElementBuilder(getSystemClass()->getSubsystemLibrary()));
    pParameterCreationLibrary->addElementBuilder(
        "ComponentType", new TNamedElementBuilderTemplate<CComponentType>());
    pParameterCreationLibrary->addElementBuilder(
        "Component", new TNamedElementBuilderTemplate<CComponentInstance>());
    pParameterCreationLibrary->addElementBuilder(
        "BitParameter", new TNamedElementBuilderTemplate<CBitParameterType>());
    pParameterCreationLibrary->addElementBuilder(
        "BitParameterBlock", new TNamedElementBuilderTemplate<CBitParameterBlockType>());
    pParameterCreationLibrary->addElementBuilder(
        "StringParameter", new TNamedElementBuilderTemplate<CStringParameterType>());
    pParameterCreationLibrary->addElementBuilder(
        "ParameterBlock", new TNamedElementBuilderTemplate<CParameterBlockType>());
    pParameterCreationLibrary->addElementBuilder(
        "BooleanParameter", new TNamedElementBuilderTemplate<CBooleanParameterType>());
    pParameterCreationLibrary->addElementBuilder(
        "IntegerParameter", new TNamedElementBuilderTemplate<CIntegerParameterType>());
    pParameterCreationLibrary->addElementBuilder(
        "LinearAdaptation", new TElementBuilderTemplate<CLinearParameterAdaptation>());
    pParameterCreationLibrary->addElementBuilder(
        "LogarithmicAdaptation", new TElementBuilderTemplate<CLogarithmicParameterAdaptation>());
    pParameterCreationLibrary->addElementBuilder(
        "EnumParameter", new TNamedElementBuilderTemplate<CEnumParameterType>());
    pParameterCreationLibrary->addElementBuilder("ValuePair",
                                                 new TElementBuilderTemplate<CEnumValuePair>());
    pParameterCreationLibrary->addElementBuilder(
        "FixedPointParameter", new TNamedElementBuilderTemplate<CFixedPointParameterType>());
    pParameterCreationLibrary->addElementBuilder(
        "FloatingPointParameter", new TNamedElementBuilderTemplate<CFloatingPointParameterType>);
    pParameterCreationLibrary->addElementBuilder(
        "SubsystemInclude",
        new CFileIncluderElementBuilder(_bValidateSchemasOnStart, getSchemaUri()));

    _pElementLibrarySet->addElementLibrary(pParameterCreationLibrary);

    // Parameter Configuration Domains creation
    CElementLibrary *pParameterConfigurationLibrary = new CElementLibrary;

    pParameterConfigurationLibrary->addElementBuilder(
        "ConfigurableDomain", new TElementBuilderTemplate<CConfigurableDomain>());
    pParameterConfigurationLibrary->addElementBuilder(
        "Configuration", new TNamedElementBuilderTemplate<CDomainConfiguration>());
    pParameterConfigurationLibrary->addElementBuilder("CompoundRule",
                                                      new TElementBuilderTemplate<CCompoundRule>());
    pParameterConfigurationLibrary->addElementBuilder(
        "SelectionCriterionRule", new TElementBuilderTemplate<CSelectionCriterionRule>());

    _pElementLibrarySet->addElementLibrary(pParameterConfigurationLibrary);
}

bool CParameterMgr::getForceNoRemoteInterface() const
{
    return _bForceNoRemoteInterface;
}

void CParameterMgr::setForceNoRemoteInterface(bool bForceNoRemoteInterface)
{
    _bForceNoRemoteInterface = bForceNoRemoteInterface;
}

CParameterMgr::CommandHandler CParameterMgr::createCommandHandler()
{
    auto commandHandler = utility::make_unique<CCommandHandler>(this);

    // Add command parsers
    for (const auto &remoteCommandParserItem : gastRemoteCommandParserItems) {
        commandHandler->addCommandParser(
            remoteCommandParserItem._pcCommandName, remoteCommandParserItem._pfnParser,
            remoteCommandParserItem._minArgumentCount, remoteCommandParserItem._pcHelp,
            remoteCommandParserItem._pcDescription);
    }

    return commandHandler;
}

bool CParameterMgr::isRemoteInterfaceRequired()
{
    // The remote interface should only be started if the client didn't
    // explicitly forbid it and if the configuration file allows it.
    return (not _bForceNoRemoteInterface) and getConstFrameworkConfiguration()->isTuningAllowed();
}

// Remote Processor Server connection handling
bool CParameterMgr::handleRemoteProcessingInterface(string &strError)
{
    LOG_CONTEXT("Handling remote processing interface");

    if (not isRemoteInterfaceRequired()) {
        return true;
    }

    auto port = getConstFrameworkConfiguration()->getServerPort();

    try {
        // The ownership of remoteComandHandler is given to Bg remote processor server.
        _pRemoteProcessorServer = new BackgroundRemoteProcessorServer(port, createCommandHandler());
    } catch (std::runtime_error &e) {
        strError = string("ParameterMgr: Unable to create Remote Processor Server: ") + e.what();
        return false;
    }

    if (_pRemoteProcessorServer == NULL) {
        strError = "ParameterMgr: Unable to create Remote Processor Server";
        return false;
    }

    if (!_pRemoteProcessorServer->start(strError)) {
        ostringstream oss;
        oss << "ParameterMgr: Unable to start remote processor server on port " << port;
        strError = oss.str() + ": " + strError;
        return false;
    }
    info() << "Remote Processor Server started on port " << port;
    return true;
}

// Children typwise access
CParameterFrameworkConfiguration *CParameterMgr::getFrameworkConfiguration()
{
    return static_cast<CParameterFrameworkConfiguration *>(getChild(EFrameworkConfiguration));
}

const CParameterFrameworkConfiguration *CParameterMgr::getConstFrameworkConfiguration()
{
    return getFrameworkConfiguration();
}

CSelectionCriteria *CParameterMgr::getSelectionCriteria()
{
    return static_cast<CSelectionCriteria *>(getChild(ESelectionCriteria));
}

const CSelectionCriteria *CParameterMgr::getConstSelectionCriteria()
{
    return static_cast<const CSelectionCriteria *>(getChild(ESelectionCriteria));
}

CSystemClass *CParameterMgr::getSystemClass()
{
    return static_cast<CSystemClass *>(getChild(ESystemClass));
}

const CSystemClass *CParameterMgr::getConstSystemClass() const
{
    return static_cast<const CSystemClass *>(getChild(ESystemClass));
}

// Configurable Domains
CConfigurableDomains *CParameterMgr::getConfigurableDomains()
{
    return static_cast<CConfigurableDomains *>(getChild(EConfigurableDomains));
}

const CConfigurableDomains *CParameterMgr::getConstConfigurableDomains()
{
    return static_cast<const CConfigurableDomains *>(getChild(EConfigurableDomains));
}

const CConfigurableDomains *CParameterMgr::getConstConfigurableDomains() const
{
    return static_cast<const CConfigurableDomains *>(getChild(EConfigurableDomains));
}

// Apply configurations
void CParameterMgr::doApplyConfigurations(bool bForce)
{
    LOG_CONTEXT("Applying configurations");

    CSyncerSet syncerSet;

    core::Results infos;
    // Check subsystems that need resync
    getSystemClass()->checkForSubsystemsToResync(syncerSet, infos);

    // Ensure application of currently selected configurations
    getConfigurableDomains()->apply(_pMainParameterBlackboard, syncerSet, bForce, infos);
    info() << infos;

    // Reset the modified status of the current criteria to indicate that a new configuration has
    // been applied
    getSelectionCriteria()->resetModifiedStatus();
}

// Export to XML string
bool CParameterMgr::exportElementToXMLString(const IXmlSource *pXmlSource,
                                             const string &strRootElementType,
                                             CXmlSerializingContext &&xmlSerializingContext,
                                             string &strResult) const
{
    // Use a doc source by loading data from instantiated Configurable Domains
    CXmlMemoryDocSource memorySource(pXmlSource, false, strRootElementType);

    // Use a doc sink that write the doc data in a string
    ostringstream output;
    CXmlStreamDocSink streamSink(output);

    // Do the export
    bool bProcessSuccess = streamSink.process(memorySource, xmlSerializingContext);

    strResult = output.str();

    return bProcessSuccess;
}

bool CParameterMgr::logResult(bool isSuccess, const std::string &result)
{
    std::string log = result.empty() ? "" : ": " + result;

    if (isSuccess) {
        info() << "Success" << log;
    } else {
        warning() << "Fail" << log;
    }

    return isSuccess;
}

log::details::Info CParameterMgr::info()
{
    return _logger.info();
}

log::details::Warning CParameterMgr::warning()
{
    return _logger.warning();
}