1/*
2 * Copyright (c) 2011-2015, Intel Corporation
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this
9 * list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation and/or
13 * other materials provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors
16 * may be used to endorse or promote products derived from this software without
17 * specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
26 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30#include "ParameterMgr.h"
31#include "XmlParameterSerializingContext.h"
32#include "XmlElementSerializingContext.h"
33#include "SystemClass.h"
34#include "ElementLibrarySet.h"
35#include "SubsystemLibrary.h"
36#include "NamedElementBuilderTemplate.h"
37#include "KindElementBuilderTemplate.h"
38#include "ElementBuilderTemplate.h"
39#include "XmlFileIncluderElement.h"
40#include "SelectionCriterionType.h"
41#include "SubsystemElementBuilder.h"
42#include "FileIncluderElementBuilder.h"
43#include "SelectionCriteria.h"
44#include "ComponentType.h"
45#include "ComponentInstance.h"
46#include "ParameterBlockType.h"
47#include "BooleanParameterType.h"
48#include "IntegerParameterType.h"
49#include "FixedPointParameterType.h"
50#include "ParameterBlackboard.h"
51#include "Parameter.h"
52#include "ParameterAccessContext.h"
53#include "XmlFileIncluderElement.h"
54#include "ParameterFrameworkConfiguration.h"
55#include "FrameworkConfigurationGroup.h"
56#include "PluginLocation.h"
57#include "SubsystemPlugins.h"
58#include "FrameworkConfigurationLocation.h"
59#include "ConfigurableDomains.h"
60#include "ConfigurableDomain.h"
61#include "DomainConfiguration.h"
62#include "XmlDomainSerializingContext.h"
63#include "XmlDomainExportContext.h"
64#include "XmlDomainImportContext.h"
65#include "BitParameterBlockType.h"
66#include "BitParameterType.h"
67#include "StringParameterType.h"
68#include "EnumParameterType.h"
69#include "RemoteProcessorServerInterface.h"
70#include "ElementLocator.h"
71#include "AutoLog.h"
72#include "CompoundRule.h"
73#include "SelectionCriterionRule.h"
74#include "SimulatedBackSynchronizer.h"
75#include "HardwareBackSynchronizer.h"
76#include "AutoLock.h"
77#include <strings.h>
78#include <dlfcn.h>
79#include <assert.h>
80#include "ParameterHandle.h"
81#include "LinearParameterAdaptation.h"
82#include "LogarithmicParameterAdaptation.h"
83#include "EnumValuePair.h"
84#include "Subsystem.h"
85#include "XmlStreamDocSink.h"
86#include "XmlMemoryDocSink.h"
87#include "XmlDocSource.h"
88#include "XmlMemoryDocSource.h"
89#include "SelectionCriteriaDefinition.h"
90#include "Utility.h"
91#include <sstream>
92#include <fstream>
93#include <algorithm>
94#include <ctype.h>
95#include <memory>
96
97#define base CElement
98
99#ifdef SIMULATION
100    // In simulation, back synchronization of the blackboard won't probably work
101    // We need to ensure though the blackboard is initialized with valid data
102    typedef CSimulatedBackSynchronizer BackSynchronizer;
103#else
104    // Real back synchronizer from subsystems
105    typedef CHardwareBackSynchronizer BackSynchronizer;
106#endif
107
108using std::string;
109using std::list;
110using std::vector;
111using std::ostringstream;
112using std::ofstream;
113using std::ifstream;
114
115// Used for remote processor server creation
116typedef IRemoteProcessorServerInterface* (*CreateRemoteProcessorServer)(uint16_t uiPort, IRemoteCommandHandler* pCommandHandler);
117
118// Global configuration file name (fixed)
119const char* gacParameterFrameworkConfigurationFileName = "ParameterFrameworkConfiguration.xml";
120const char* gacSystemSchemasSubFolder = "Schemas";
121
122// Config File System looks normally like this:
123// ---------------------------------------------
124//|-- <ParameterFrameworkConfiguration>.xml
125//|-- Schemas
126//|   `-- *.xsd
127//|-- Settings
128//|   `-- <SystemClassName folder>*
129//|       |-- <ConfigurableDomains>.xml
130//|       `-- <Settings>.bin?
131//`-- Structure
132//    `-- <SystemClassName folder>*
133//        |-- <SystemClassName>Class.xml
134//        `-- <Subsystem>.xml*
135// --------------------------------------------
136
137
138// Remote command parser array
139const CParameterMgr::SRemoteCommandParserItem CParameterMgr::gastRemoteCommandParserItems[] = {
140
141    /// Version
142    { "version", &CParameterMgr::versionCommandProcess, 0,
143            "", "Show version" },
144
145    /// Status
146    { "status", &CParameterMgr::statusCommandProcess, 0, "",
147            "Show current status" },
148
149    /// Tuning Mode
150    { "setTuningMode", &CParameterMgr::setTuningModeCommandProcess, 1,
151            "on|off*", "Turn on or off Tuning Mode" },
152    { "getTuningMode", &CParameterMgr::getTuningModeCommandProcess, 0,
153            "", "Show Tuning Mode" },
154
155    /// Value Space
156    { "setValueSpace", &CParameterMgr::setValueSpaceCommandProcess, 1,
157            "raw|real*", "Assigns Value Space used for parameter value interpretation" },
158    { "getValueSpace", &CParameterMgr::getValueSpaceCommandProcess, 0,
159            "", "Show Value Space" },
160
161    /// Output Raw Format
162    { "setOutputRawFormat", &CParameterMgr::setOutputRawFormatCommandProcess, 1,
163            "dec*|hex", "Assigns format used to output parameter values when in raw Value Space" },
164    { "getOutputRawFormat", &CParameterMgr::getOutputRawFormatCommandProcess, 0,
165            "", "Show Output Raw Format" },
166
167    /// Sync
168    { "setAutoSync", &CParameterMgr::setAutoSyncCommandProcess, 1,
169            "on*|off", "Turn on or off automatic synchronization to hardware while in Tuning Mode" },
170    { "getAutoSync", &CParameterMgr::getAutoSyncCommandProcess, 0,
171            "", "Show Auto Sync state" },
172    { "sync", &CParameterMgr::syncCommandProcess, 0,
173            "", "Synchronize current settings to hardware while in Tuning Mode and Auto Sync off" },
174
175    /// Criteria
176    { "listCriteria", &CParameterMgr::listCriteriaCommandProcess, 0,
177            "[CSV|XML]", "List selection criteria" },
178
179    /// Domains
180    { "listDomains", &CParameterMgr::listDomainsCommandProcess, 0,
181            "", "List configurable domains" },
182    { "dumpDomains", &CParameterMgr::dumpDomainsCommandProcess, 0,
183            "", "Show all domains and configurations, including applicability conditions" },
184    { "createDomain", &CParameterMgr::createDomainCommandProcess, 1,
185            "<domain>", "Create new configurable domain" },
186    { "deleteDomain", &CParameterMgr::deleteDomainCommandProcess, 1,
187            "<domain>", "Delete configurable domain" },
188    { "deleteAllDomains", &CParameterMgr::deleteAllDomainsCommandProcess, 0,
189            "", "Delete all configurable domains" },
190    { "renameDomain", &CParameterMgr::renameDomainCommandProcess, 2,
191            "<domain> <new name>", "Rename configurable domain" },
192    { "setSequenceAwareness", &CParameterMgr::setSequenceAwarenessCommandProcess, 1,
193            "<domain> true|false*", "Set configurable domain sequence awareness" },
194    { "getSequenceAwareness", &CParameterMgr::getSequenceAwarenessCommandProcess, 1,
195            "<domain>", "Get configurable domain sequence awareness" },
196    { "listDomainElements", &CParameterMgr::listDomainElementsCommandProcess, 1,
197            "<domain>", "List elements associated to configurable domain" },
198    { "addElement", &CParameterMgr::addElementCommandProcess, 2,
199            "<domain> <elem path>", "Associate element at given path to configurable domain" },
200    { "removeElement", &CParameterMgr::removeElementCommandProcess, 2,
201            "<domain> <elem path>", "Dissociate element at given path from configurable domain" },
202    { "splitDomain", &CParameterMgr::splitDomainCommandProcess, 2,
203            "<domain> <elem path>", "Split configurable domain at given associated element path" },
204
205    /// Configurations
206    { "listConfigurations", &CParameterMgr::listConfigurationsCommandProcess, 1,
207            "<domain>", "List domain configurations" },
208    { "createConfiguration", &CParameterMgr::createConfigurationCommandProcess, 2,
209            "<domain> <configuration>", "Create new domain configuration" },
210    { "deleteConfiguration", &CParameterMgr::deleteConfigurationCommandProcess, 2,
211            "<domain> <configuration>", "Delete domain configuration" },
212    { "renameConfiguration", &CParameterMgr::renameConfigurationCommandProcess, 3,
213            "<domain> <configuration> <new name>", "Rename domain configuration" },
214    { "saveConfiguration", &CParameterMgr::saveConfigurationCommandProcess, 2,
215            "<domain> <configuration>", "Save current settings into configuration" },
216    { "restoreConfiguration", &CParameterMgr::restoreConfigurationCommandProcess, 2,
217            "<domain> <configuration>", "Restore current settings from configuration" },
218    { "setElementSequence", &CParameterMgr::setElementSequenceCommandProcess, 3,
219            "<domain> <configuration> <elem path list>",
220            "Set element application order for configuration" },
221    { "getElementSequence", &CParameterMgr::getElementSequenceCommandProcess, 2,
222            "<domain> <configuration>", "Get element application order for configuration" },
223    { "setRule", &CParameterMgr::setRuleCommandProcess, 3,
224            "<domain> <configuration> <rule>", "Set configuration application rule" },
225    { "clearRule", &CParameterMgr::clearRuleCommandProcess, 2,
226            "<domain> <configuration>", "Clear configuration application rule" },
227    { "getRule", &CParameterMgr::getRuleCommandProcess, 2,
228            "<domain> <configuration>", "Get configuration application rule" },
229
230    /// Elements/Parameters
231    { "listElements", &CParameterMgr::listElementsCommandProcess, 1,
232            "<elem path>|/", "List elements under element at given path or root" },
233    { "listParameters", &CParameterMgr::listParametersCommandProcess, 1,
234            "<elem path>|/", "List parameters under element at given path or root" },
235    { "dumpElement", &CParameterMgr::dumpElementCommandProcess, 1,
236            "<elem path>", "Dump structure and content of element at given path" },
237    { "getElementSize", &CParameterMgr::getElementSizeCommandProcess, 1,
238            "<elem path>", "Show size of element at given path" },
239    { "showProperties", &CParameterMgr::showPropertiesCommandProcess, 1,
240            "<elem path>", "Show properties of element at given path" },
241    { "getParameter", &CParameterMgr::getParameterCommandProcess, 1,
242            "<param path>", "Get value for parameter at given path" },
243    { "setParameter", &CParameterMgr::setParameterCommandProcess, 2,
244            "<param path> <value>", "Set value for parameter at given path" },
245    { "listBelongingDomains", &CParameterMgr::listBelongingDomainsCommandProcess, 1,
246            "<elem path>", "List domain(s) element at given path belongs to" },
247    { "listAssociatedDomains", &CParameterMgr::listAssociatedDomainsCommandProcess, 1,
248            "<elem path>", "List domain(s) element at given path is associated to" },
249    { "getConfigurationParameter", &CParameterMgr::getConfigurationParameterCommandProcess, 3,
250            "<domain> <configuration> <param path>",
251            "Get value for parameter at given path from configuration" },
252    { "setConfigurationParameter", &CParameterMgr::setConfigurationParameterCommandProcess, 4,
253            "<domain> <configuration> <param path> <value>",
254            "Set value for parameter at given path to configuration" },
255    { "showMapping", &CParameterMgr::showMappingCommandProcess, 1,
256            "<elem path>", "Show mapping for an element at given path" },
257
258    /// Browse
259    { "listAssociatedElements", &CParameterMgr::listAssociatedElementsCommandProcess, 0,
260            "", "List element sub-trees associated to at least one configurable domain" },
261    { "listConflictingElements", &CParameterMgr::listConflictingElementsCommandProcess, 0,
262            "", "List element sub-trees contained in more than one configurable domain" },
263    { "listRogueElements", &CParameterMgr::listRogueElementsCommandProcess, 0,
264            "", "List element sub-trees owned by no configurable domain" },
265
266    /// Settings Import/Export
267    { "exportDomainsXML", &CParameterMgr::exportDomainsXMLCommandProcess, 1,
268            "<file path> ", "Export domains to an XML file (provide an absolute path or relative"
269                            "to the client's working directory)" },
270    { "importDomainsXML", &CParameterMgr::importDomainsXMLCommandProcess, 1,
271            "<file path>", "Import domains from an XML file (provide an absolute path or relative"
272                            "to the client's working directory)" },
273    { "exportDomainsWithSettingsXML",
274            &CParameterMgr::exportDomainsWithSettingsXMLCommandProcess, 1,
275            "<file path> ", "Export domains including settings to XML file (provide an absolute path or relative"
276                            "to the client's working directory)" },
277    { "exportDomainWithSettingsXML",
278            &CParameterMgr::exportDomainWithSettingsXMLCommandProcess, 2,
279            "<domain> <file path> ", "Export a single given domain including settings to XML file"
280                                     " (provide an absolute path or relative to the client's"
281                                     " working directory)" },
282    { "importDomainsWithSettingsXML",
283            &CParameterMgr::importDomainsWithSettingsXMLCommandProcess, 1,
284            "<file path>", "Import domains including settings from XML file (provide an absolute path or relative"
285                            "to the client's working directory)" },
286    { "importDomainWithSettingsXML",
287            &CParameterMgr::importDomainWithSettingsXMLCommandProcess, 1,
288            "<file path> [overwrite]", "Import a single domain including settings from XML file."
289            " Does not overwrite an existing domain unless 'overwrite' is passed as second"
290            " argument. Provide an absolute path or relative to the client's working directory)" },
291    { "exportSettings", &CParameterMgr::exportSettingsCommandProcess, 1,
292            "<file path>", "Export settings to binary file (provide an absolute path or relative"
293                            "to the client's working directory)" },
294    { "importSettings", &CParameterMgr::importSettingsCommandProcess, 1,
295            "<file path>", "Import settings from binary file (provide an absolute path or relative"
296                            "to the client's working directory)" },
297    { "getDomainsWithSettingsXML",
298            &CParameterMgr::getDomainsWithSettingsXMLCommandProcess, 0,
299            "", "Print domains including settings as XML" },
300    { "getDomainWithSettingsXML",
301            &CParameterMgr::getDomainWithSettingsXMLCommandProcess, 1,
302            "<domain>", "Print the given domain including settings as XML" },
303    { "setDomainsWithSettingsXML",
304            &CParameterMgr::setDomainsWithSettingsXMLCommandProcess, 1,
305            "<xml configurable domains>", "Import domains including settings from XML string" },
306    { "setDomainWithSettingsXML",
307            &CParameterMgr::setDomainWithSettingsXMLCommandProcess, 1,
308            "<xml configurable domain> [overwrite]", "Import domains including settings from XML"
309            " string. Does not overwrite an existing domain unless 'overwrite' is passed as second"
310            " argument" },
311    /// Structure Export
312    { "getSystemClassXML", &CParameterMgr::getSystemClassXMLCommandProcess, 0 ,
313            "", "Print parameter structure as XML" },
314    /// Deprecated Commands
315    { "getDomainsXML",
316            &CParameterMgr::getDomainsWithSettingsXMLCommandProcess, 0,
317            "", "DEPRECATED COMMAND, please use getDomainsWithSettingsXML" },
318
319};
320
321// Remote command parsers array Size
322const uint32_t CParameterMgr::guiNbRemoteCommandParserItems = sizeof(gastRemoteCommandParserItems) / sizeof(gastRemoteCommandParserItems[0]);
323
324CParameterMgr::CParameterMgr(const string& strConfigurationFilePath) :
325    _bTuningModeIsOn(false),
326    _bValueSpaceIsRaw(false),
327    _bOutputRawFormatIsHex(false),
328    _bAutoSyncOn(true),
329    _pMainParameterBlackboard(new CParameterBlackboard),
330    _pElementLibrarySet(new CElementLibrarySet),
331    _strXmlConfigurationFilePath(strConfigurationFilePath),
332    _pSubsystemPlugins(NULL),
333    _pvLibRemoteProcessorHandle(NULL),
334    _uiStructureChecksum(0),
335    _pRemoteProcessorServer(NULL),
336    _uiMaxCommandUsageLength(0),
337    _pLogger(NULL),
338    _uiLogDepth(0),
339    _bForceNoRemoteInterface(false),
340    _bFailOnMissingSubsystem(true),
341    _bFailOnFailedSettingsLoad(true),
342    _bValidateSchemasOnStart(false)
343
344{
345    // Tuning Mode Mutex
346    bzero(&_blackboardMutex, sizeof(_blackboardMutex));
347    pthread_mutex_init(&_blackboardMutex, NULL);
348
349    // Deal with children
350    addChild(new CParameterFrameworkConfiguration);
351    addChild(new CSelectionCriteria);
352    addChild(new CSystemClass);
353    addChild(new CConfigurableDomains);
354
355    _pCommandHandler = new CCommandHandler(this);
356
357    // Add command parsers
358    uint32_t uiRemoteCommandParserItem;
359
360    for (uiRemoteCommandParserItem = 0; uiRemoteCommandParserItem < guiNbRemoteCommandParserItems; uiRemoteCommandParserItem++) {
361
362        const SRemoteCommandParserItem* pRemoteCommandParserItem = &gastRemoteCommandParserItems[uiRemoteCommandParserItem];
363
364        _pCommandHandler->addCommandParser(pRemoteCommandParserItem->_pcCommandName,
365                                           pRemoteCommandParserItem->_pfnParser,
366                                           pRemoteCommandParserItem->_uiMinArgumentCount,
367                                           pRemoteCommandParserItem->_pcHelp,
368                                           pRemoteCommandParserItem->_pcDescription);
369    }
370
371    // Configuration file folder
372    std::string::size_type slashPos = _strXmlConfigurationFilePath.rfind('/', -1);
373    if(slashPos == std::string::npos) {
374        // Configuration folder is the current folder
375        _strXmlConfigurationFolderPath = '.';
376    } else {
377        _strXmlConfigurationFolderPath = _strXmlConfigurationFilePath.substr(0, slashPos);
378    }
379
380    // Schema absolute folder location
381    _strSchemaFolderLocation = _strXmlConfigurationFolderPath + "/" + gacSystemSchemasSubFolder;
382}
383
384CParameterMgr::~CParameterMgr()
385{
386    // Children
387    delete _pRemoteProcessorServer;
388    delete _pCommandHandler;
389    delete _pMainParameterBlackboard;
390    delete _pElementLibrarySet;
391
392    // Close remote processor library
393    if (_pvLibRemoteProcessorHandle) {
394
395        dlclose(_pvLibRemoteProcessorHandle);
396    }
397
398    // Tuning Mode Mutex
399    pthread_mutex_destroy(&_blackboardMutex);
400}
401
402string CParameterMgr::getKind() const
403{
404    return "ParameterMgr";
405}
406
407// Logging
408void CParameterMgr::setLogger(CParameterMgr::ILogger* pLogger)
409{
410    _pLogger = pLogger;
411}
412
413// Logging
414void CParameterMgr::doLog(bool bIsWarning, const string& strLog) const
415{
416    if (_pLogger) {
417
418        // Nest
419        string strIndent;
420
421        // Level
422        uint32_t uiNbIndents = _uiLogDepth;
423
424        while (uiNbIndents--) {
425
426            strIndent += "    ";
427        }
428
429        // Log
430        _pLogger->log(bIsWarning, strIndent + strLog);
431    }
432}
433
434void CParameterMgr::nestLog() const
435{
436    _uiLogDepth++;
437}
438
439void CParameterMgr::unnestLog() const
440{
441    _uiLogDepth--;
442}
443
444// Version
445string CParameterMgr::getVersion() const
446{
447    string strVersion;
448
449    // Major
450    strVersion = CUtility::toString(guiEditionMajor) + ".";
451    // Minor
452    strVersion += CUtility::toString(guiEditionMinor) + ".";
453    // Revision
454    strVersion += CUtility::toString(guiRevision);
455
456    return strVersion;
457}
458
459bool CParameterMgr::load(string& strError)
460{
461    CAutoLog autoLog(this, "Loading");
462
463    feedElementLibraries();
464
465    // Load Framework configuration
466    if (!loadFrameworkConfiguration(strError)) {
467
468        return false;
469    }
470
471    // Load subsystems
472    if (!getSystemClass()->loadSubsystems(strError,
473                                          _pSubsystemPlugins, !_bFailOnMissingSubsystem)) {
474
475        return false;
476    }
477
478    // Load structure
479    if (!loadStructure(strError)) {
480
481        return false;
482    }
483
484    // Load settings
485    if (!loadSettings(strError)) {
486
487        return false;
488    }
489
490    // Init flow of element tree
491    if (!init(strError)) {
492
493        return false;
494    }
495
496
497    {
498        CAutoLog autoLog(this, "Main blackboard back synchronization");
499
500	// Back synchronization for areas in parameter blackboard not covered by any domain
501	BackSynchronizer(getConstSystemClass(), _pMainParameterBlackboard).sync();
502    }
503
504    // We're done loading the settings and back synchronizing
505    CConfigurableDomains* pConfigurableDomains = getConfigurableDomains();
506
507    // We need to ensure all domains are valid
508    pConfigurableDomains->validate(_pMainParameterBlackboard);
509
510    // Log selection criterion states
511    {
512        CAutoLog autoLog(this, "Criterion states");
513
514        const CSelectionCriteria* selectionCriteria = getConstSelectionCriteria();
515
516        list<string> lstrSelectionCriteron;
517        selectionCriteria->listSelectionCriteria(lstrSelectionCriteron, true, false);
518
519        log_table(false, lstrSelectionCriteron);
520    }
521
522    // Subsystem can not ask for resync as they have not been synced yet
523    getSystemClass()->cleanSubsystemsNeedToResync();
524
525    // At initialization, check subsystems that need resync
526    doApplyConfigurations(true);
527
528    // Start remote processor server if appropriate
529    return handleRemoteProcessingInterface(strError);
530}
531
532bool CParameterMgr::loadFrameworkConfiguration(string& strError)
533{
534    CAutoLog autoLog(this, "Loading framework configuration");
535
536    // Parse Structure XML file
537    CXmlElementSerializingContext elementSerializingContext(strError);
538
539    _xmlDoc *doc = CXmlDocSource::mkXmlDoc(_strXmlConfigurationFilePath, true, true, strError);
540    if (doc == NULL) {
541        return false;
542    }
543
544    if (!xmlParse(elementSerializingContext, getFrameworkConfiguration(), doc,
545                  _strXmlConfigurationFolderPath, EFrameworkConfigurationLibrary)) {
546
547        return false;
548    }
549    // Set class name to system class and configurable domains
550    getSystemClass()->setName(getConstFrameworkConfiguration()->getSystemClassName());
551    getConfigurableDomains()->setName(getConstFrameworkConfiguration()->getSystemClassName());
552
553    // Get subsystem plugins elements
554    _pSubsystemPlugins = static_cast<const CSubsystemPlugins*>(getConstFrameworkConfiguration()->findChild("SubsystemPlugins"));
555
556    if (!_pSubsystemPlugins) {
557
558        strError = "Parameter Framework Configuration: couldn't find SubsystemPlugins element";
559
560        return false;
561    }
562
563    // Log tuning availability
564    log_info("Tuning %s", getConstFrameworkConfiguration()->isTuningAllowed() ? "allowed" : "prohibited");
565
566    return true;
567}
568
569bool CParameterMgr::loadStructure(string& strError)
570{
571    // Retrieve system to load structure to
572    CSystemClass* pSystemClass = getSystemClass();
573
574    log_info("Loading %s system class structure", pSystemClass->getName().c_str());
575
576    // Get structure description element
577    const CFrameworkConfigurationLocation* pStructureDescriptionFileLocation = static_cast<const CFrameworkConfigurationLocation*>(getConstFrameworkConfiguration()->findChildOfKind("StructureDescriptionFileLocation"));
578
579    if (!pStructureDescriptionFileLocation) {
580
581        strError = "No StructureDescriptionFileLocation element found for SystemClass " + pSystemClass->getName();
582
583        return false;
584    }
585
586    // Get Xml structure folder
587    string strXmlStructureFolder = pStructureDescriptionFileLocation->getFolderPath(_strXmlConfigurationFolderPath);
588
589    // Get Xml structure file name
590    string strXmlStructureFilePath = pStructureDescriptionFileLocation->getFilePath(_strXmlConfigurationFolderPath);
591
592    // Parse Structure XML file
593    CXmlParameterSerializingContext parameterBuildContext(strError);
594
595    CAutoLog autolog(pSystemClass, "Importing system structure from file " + strXmlStructureFilePath);
596
597    _xmlDoc *doc = CXmlDocSource::mkXmlDoc(strXmlStructureFilePath, true, true, strError);
598    if (doc == NULL) {
599        return false;
600    }
601
602    if (!xmlParse(parameterBuildContext, pSystemClass, doc, strXmlStructureFolder, EParameterCreationLibrary)) {
603
604        return false;
605    }
606
607    // Initialize offsets
608    pSystemClass->setOffset(0);
609
610    // Initialize main blackboard's size
611    _pMainParameterBlackboard->setSize(pSystemClass->getFootPrint());
612
613    return true;
614}
615
616bool CParameterMgr::loadSettings(string& strError)
617{
618    string strLoadError;
619    bool success = loadSettingsFromConfigFile(strLoadError);
620
621    if (!success && !_bFailOnFailedSettingsLoad) {
622        // Load can not fail, ie continue but log the load errors
623        log_info("%s", strLoadError.c_str());
624        log_info("Failed to load settings, continue without domains.");
625        success = true;
626    }
627
628    if (!success) {
629        // Propagate the litteral error only if the function fails
630        strError = strLoadError;
631        return false;
632    }
633
634    return true;
635}
636
637bool CParameterMgr::loadSettingsFromConfigFile(string& strError)
638{
639    CAutoLog autoLog(this, "Loading settings");
640
641    // Get settings configuration element
642    const CFrameworkConfigurationGroup* pParameterConfigurationGroup = static_cast<const CFrameworkConfigurationGroup*>(getConstFrameworkConfiguration()->findChildOfKind("SettingsConfiguration"));
643
644    if (!pParameterConfigurationGroup) {
645
646        // No settings to load
647
648        return true;
649    }
650    // Get binary settings file location
651    const CFrameworkConfigurationLocation* pBinarySettingsFileLocation = static_cast<const CFrameworkConfigurationLocation*>(pParameterConfigurationGroup->findChildOfKind("BinarySettingsFileLocation"));
652
653    string strXmlBinarySettingsFilePath;
654
655    if (pBinarySettingsFileLocation) {
656
657        // Get Xml binary settings file name
658        strXmlBinarySettingsFilePath = pBinarySettingsFileLocation->getFilePath(_strXmlConfigurationFolderPath);
659    }
660
661    // Get configurable domains element
662    const CFrameworkConfigurationLocation* pConfigurableDomainsFileLocation = static_cast<const CFrameworkConfigurationLocation*>(pParameterConfigurationGroup->findChildOfKind("ConfigurableDomainsFileLocation"));
663
664    if (!pConfigurableDomainsFileLocation) {
665
666        strError = "No ConfigurableDomainsFileLocation element found for SystemClass " + getSystemClass()->getName();
667
668        return false;
669    }
670    // Get destination root element
671    CConfigurableDomains* pConfigurableDomains = getConfigurableDomains();
672
673    // Get Xml configuration domains file name
674    string strXmlConfigurationDomainsFilePath = pConfigurableDomainsFileLocation->getFilePath(_strXmlConfigurationFolderPath);
675
676    // Get Xml configuration domains folder
677    string strXmlConfigurationDomainsFolder = pConfigurableDomainsFileLocation->getFolderPath(_strXmlConfigurationFolderPath);
678
679    // Parse configuration domains XML file (ask to read settings from XML file if they are not provided as binary)
680    CXmlDomainImportContext xmlDomainImportContext(strError, !pBinarySettingsFileLocation,
681            *getSystemClass());
682
683    // Selection criteria definition for rule creation
684    xmlDomainImportContext.setSelectionCriteriaDefinition(getConstSelectionCriteria()->getSelectionCriteriaDefinition());
685
686    // Auto validation of configurations if no binary settings provided
687    xmlDomainImportContext.setAutoValidationRequired(!pBinarySettingsFileLocation);
688
689    log_info("Importing configurable domains from file %s %s settings", strXmlConfigurationDomainsFilePath.c_str(), pBinarySettingsFileLocation ? "without" : "with");
690
691    _xmlDoc *doc = CXmlDocSource::mkXmlDoc(strXmlConfigurationDomainsFilePath, true, true, strError);
692    if (doc == NULL) {
693        return false;
694    }
695
696    if (!xmlParse(xmlDomainImportContext, pConfigurableDomains, doc, strXmlConfigurationDomainsFolder, EParameterConfigurationLibrary, "SystemClassName")) {
697
698        return false;
699    }
700    // We have loaded the whole system structure, compute checksum
701    const CSystemClass* pSystemClass = getConstSystemClass();
702    _uiStructureChecksum = pSystemClass->computeStructureChecksum() + getConfigurableDomains()->computeStructureChecksum() + getSelectionCriteria()->computeStructureChecksum();
703
704    // Load binary settings if any provided
705    if (pBinarySettingsFileLocation && !pConfigurableDomains->serializeSettings(strXmlBinarySettingsFilePath, false, _uiStructureChecksum, strError)) {
706
707        return false;
708    }
709
710    return true;
711}
712
713// XML parsing
714bool CParameterMgr::xmlParse(CXmlElementSerializingContext& elementSerializingContext,
715                             CElement* pRootElement, _xmlDoc* doc,
716                             const string& strXmlFolder,
717                             CParameterMgr::ElementLibrary eElementLibrary,
718                             const string& strNameAttributeName)
719{
720    // Init serializing context
721    elementSerializingContext.set(_pElementLibrarySet->getElementLibrary(
722                                      eElementLibrary), strXmlFolder, _strSchemaFolderLocation);
723
724    // Get Schema file associated to root element
725    string strXmlSchemaFilePath = _strSchemaFolderLocation + "/" + pRootElement->getKind() + ".xsd";
726
727    CXmlDocSource docSource(doc, _bValidateSchemasOnStart,
728                            strXmlSchemaFilePath,
729                            pRootElement->getKind(),
730                            pRootElement->getName(),
731                            strNameAttributeName);
732
733    // Start clean
734    pRootElement->clean();
735
736    CXmlMemoryDocSink memorySink(pRootElement);
737
738    if (!memorySink.process(docSource, elementSerializingContext)) {
739        //Cleanup
740        pRootElement->clean();
741
742        return false;
743    }
744
745    return true;
746}
747
748// Init
749bool CParameterMgr::init(string& strError)
750{
751    return base::init(strError);
752}
753
754// Selection criteria interface
755CSelectionCriterionType* CParameterMgr::createSelectionCriterionType(bool bIsInclusive)
756{
757    // Propagate
758    return getSelectionCriteria()->createSelectionCriterionType(bIsInclusive);
759}
760
761CSelectionCriterion* CParameterMgr::createSelectionCriterion(const string& strName, const CSelectionCriterionType* pSelectionCriterionType)
762{
763    // Propagate
764    return getSelectionCriteria()->createSelectionCriterion(strName, pSelectionCriterionType);
765}
766
767// Selection criterion retrieval
768CSelectionCriterion* CParameterMgr::getSelectionCriterion(const string& strName)
769{
770    // Propagate
771    return getSelectionCriteria()->getSelectionCriterion(strName);
772}
773
774// Configuration application
775void CParameterMgr::applyConfigurations()
776{
777    CAutoLog autoLog(this, "Configuration application request");
778
779    // Lock state
780    CAutoLock autoLock(&_blackboardMutex);
781
782    if (!_bTuningModeIsOn) {
783
784        // Apply configuration(s)
785        doApplyConfigurations(false);
786    } else {
787
788        log_warning("Configurations were not applied because the TuningMode is on");
789    }
790}
791
792// Get the configurableElement corresponding to the given path
793const CConfigurableElement* CParameterMgr::getConfigurableElement(const string& strPath,
794                                                                  string& strError) const
795{
796    CPathNavigator pathNavigator(strPath);
797
798    // Nagivate through system class
799    if (!pathNavigator.navigateThrough(getConstSystemClass()->getName(), strError)) {
800
801        return NULL;
802    }
803
804    // Find element
805    const CElement* pElement = getConstSystemClass()->findDescendant(pathNavigator);
806
807    if (!pElement) {
808
809        strError = "Path not found: " + strPath;
810
811        return NULL;
812    }
813
814    // Check found element is a parameter
815    const CConfigurableElement* pConfigurableElement = static_cast<const CConfigurableElement*>(pElement);
816
817    return pConfigurableElement;
818}
819
820// Dynamic parameter handling
821CParameterHandle* CParameterMgr::createParameterHandle(const string& strPath, string& strError)
822{
823    const CConfigurableElement* pConfigurableElement = getConfigurableElement(strPath, strError);
824
825    if (!pConfigurableElement) {
826
827        // Element not found
828        strError = "Element not found: " + strPath;
829        return NULL;
830    }
831
832    if (!pConfigurableElement->isParameter()) {
833
834        // Element is not parameter
835        strError = "Not a parameter: " + strPath;
836
837        return NULL;
838    }
839
840    // Convert as parameter and return new handle
841    return new CParameterHandle(static_cast<const CBaseParameter*>(pConfigurableElement), this);
842}
843
844void CParameterMgr::setFailureOnMissingSubsystem(bool bFail)
845{
846    _bFailOnMissingSubsystem = bFail;
847}
848
849bool CParameterMgr::getFailureOnMissingSubsystem() const
850{
851    return _bFailOnMissingSubsystem;
852}
853
854void CParameterMgr::setFailureOnFailedSettingsLoad(bool bFail)
855{
856    _bFailOnFailedSettingsLoad = bFail;
857}
858
859bool CParameterMgr::getFailureOnFailedSettingsLoad()
860{
861    return _bFailOnFailedSettingsLoad;
862}
863
864const string& CParameterMgr::getSchemaFolderLocation() const
865{
866    return _strSchemaFolderLocation;
867}
868
869void CParameterMgr::setSchemaFolderLocation(const string& strSchemaFolderLocation)
870{
871    _strSchemaFolderLocation = strSchemaFolderLocation;
872}
873
874void CParameterMgr::setValidateSchemasOnStart(bool bValidate)
875{
876    _bValidateSchemasOnStart = bValidate;
877}
878
879bool CParameterMgr::getValidateSchemasOnStart() const
880{
881    return _bValidateSchemasOnStart;
882}
883
884/////////////////// Remote command parsers
885/// Version
886CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::versionCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
887{
888    (void)remoteCommand;
889
890    // Show version
891    strResult = getVersion();
892
893    return CCommandHandler::ESucceeded;
894}
895
896/// Status
897CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::statusCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
898{
899    (void)remoteCommand;
900    // System class
901    const CSystemClass* pSystemClass = getSystemClass();
902
903    // Show status
904    /// General section
905    CUtility::appendTitle(strResult, "General:");
906    // System class
907    strResult += "System Class: ";
908    strResult += pSystemClass->getName();
909    strResult += "\n";
910
911    // Tuning mode
912    strResult += "Tuning Mode: ";
913    strResult += tuningModeOn() ? "on" : "off";
914    strResult += "\n";
915
916    // Value space
917    strResult += "Value Space: ";
918    strResult += valueSpaceIsRaw() ? "raw" : "real";
919    strResult += "\n";
920
921    // Output raw format
922    strResult += "Output Raw Format: ";
923    strResult += outputRawFormatIsHex() ? "hex" : "dec";
924    strResult += "\n";
925
926    // Auto Sync
927    strResult += "Auto Sync: ";
928    strResult += autoSyncOn() ? "on" : "off";
929    strResult += "\n";
930
931    /// Subsystem list
932    CUtility::appendTitle(strResult, "Subsystems:");
933    string strSubsystemList;
934    pSystemClass->listChildrenPaths(strSubsystemList);
935    strResult += strSubsystemList;
936
937    /// Last applied configurations
938    CUtility::appendTitle(strResult, "Last Applied [Pending] Configurations:");
939    string strLastAppliedConfigurations;
940    getConfigurableDomains()->listLastAppliedConfigurations(strLastAppliedConfigurations);
941    strResult += strLastAppliedConfigurations;
942
943    /// Criteria states
944    CUtility::appendTitle(strResult, "Selection Criteria:");
945    list<string> lstrSelectionCriteria;
946    getSelectionCriteria()->listSelectionCriteria(lstrSelectionCriteria, false, true);
947    // Concatenate the criterion list as the command result
948    string strCriteriaStates;
949    CUtility::asString(lstrSelectionCriteria, strCriteriaStates);
950    strResult += strCriteriaStates;
951
952    return CCommandHandler::ESucceeded;
953}
954
955/// Tuning Mode
956CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setTuningModeCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
957{
958    if (remoteCommand.getArgument(0) == "on") {
959
960        if (setTuningMode(true, strResult)) {
961
962            return CCommandHandler::EDone;
963        }
964    } else if (remoteCommand.getArgument(0) == "off") {
965
966        if (setTuningMode(false, strResult)) {
967
968            return CCommandHandler::EDone;
969        }
970    } else {
971        // Show usage
972        return CCommandHandler::EShowUsage;
973    }
974    return CCommandHandler::EFailed;
975}
976
977CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getTuningModeCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
978{
979    (void)remoteCommand;
980
981    strResult = tuningModeOn() ? "on" : "off";
982
983    return CCommandHandler::ESucceeded;
984}
985
986/// Value Space
987CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setValueSpaceCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
988{
989    (void)strResult;
990
991    if (remoteCommand.getArgument(0) == "raw") {
992
993        setValueSpace(true);
994
995        return CCommandHandler::EDone;
996
997    } else if (remoteCommand.getArgument(0) == "real") {
998
999        setValueSpace(false);
1000
1001        return CCommandHandler::EDone;
1002
1003    } else {
1004        // Show usage
1005        return CCommandHandler::EShowUsage;
1006    }
1007    return CCommandHandler::EFailed;
1008}
1009
1010CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getValueSpaceCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1011{
1012    (void)remoteCommand;
1013
1014    strResult = valueSpaceIsRaw() ? "raw" : "real";
1015
1016    return CCommandHandler::ESucceeded;
1017}
1018
1019/// Output Raw Format
1020CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setOutputRawFormatCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1021{
1022    (void)strResult;
1023
1024    if (remoteCommand.getArgument(0) == "hex") {
1025
1026        setOutputRawFormat(true);
1027
1028        return CCommandHandler::EDone;
1029
1030    } else if (remoteCommand.getArgument(0) == "dec") {
1031
1032        setOutputRawFormat(false);
1033
1034        return CCommandHandler::EDone;
1035
1036    } else {
1037        // Show usage
1038        return CCommandHandler::EShowUsage;
1039    }
1040    return CCommandHandler::EFailed;
1041}
1042
1043CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getOutputRawFormatCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1044{
1045    (void)remoteCommand;
1046
1047    strResult = outputRawFormatIsHex() ? "hex" : "dec";
1048
1049    return CCommandHandler::ESucceeded;
1050}
1051
1052/// Sync
1053CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setAutoSyncCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1054{
1055    if (remoteCommand.getArgument(0) == "on") {
1056
1057        if (setAutoSync(true, strResult)) {
1058
1059            return CCommandHandler::EDone;
1060        }
1061    } else if (remoteCommand.getArgument(0) == "off") {
1062
1063        if (setAutoSync(false, strResult)) {
1064
1065            return CCommandHandler::EDone;
1066        }
1067    } else {
1068        // Show usage
1069        return CCommandHandler::EShowUsage;
1070    }
1071    return CCommandHandler::EFailed;
1072}
1073
1074CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getAutoSyncCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1075{
1076    (void)remoteCommand;
1077
1078    strResult = autoSyncOn() ? "on" : "off";
1079
1080    return CCommandHandler::ESucceeded;
1081}
1082
1083CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::syncCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1084{
1085    (void)remoteCommand;
1086
1087    return sync(strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1088}
1089
1090/// Criteria
1091CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listCriteriaCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1092{
1093    if (remoteCommand.getArgumentCount() > 1) {
1094
1095        return CCommandHandler::EShowUsage;
1096    }
1097
1098    string strOutputFormat;
1099
1100    // Look for optional arguments
1101    if (remoteCommand.getArgumentCount() == 1) {
1102
1103        // Get requested format
1104        strOutputFormat = remoteCommand.getArgument(0);
1105
1106        // Capitalize
1107        std::transform(strOutputFormat.begin(), strOutputFormat.end(), strOutputFormat.begin(), ::toupper);
1108
1109        if (strOutputFormat != "XML" && strOutputFormat != "CSV") {
1110
1111            return CCommandHandler::EShowUsage;
1112        }
1113    }
1114
1115    if (strOutputFormat == "XML") {
1116        // Get Root element where to export from
1117        const CSelectionCriteriaDefinition* pSelectionCriteriaDefinition = getConstSelectionCriteria()->getSelectionCriteriaDefinition();
1118
1119        if (!exportElementToXMLString(pSelectionCriteriaDefinition, "SelectionCriteria",
1120                                      strResult)) {
1121
1122            return CCommandHandler::EFailed;
1123        }
1124
1125        // Succeeded
1126        return CCommandHandler::ESucceeded;
1127    } else {
1128
1129        // Requested format will be either CSV or human readable based on strOutputFormat content
1130        bool bHumanReadable = strOutputFormat.empty();
1131
1132        list<string> lstrResult;
1133        getSelectionCriteria()->listSelectionCriteria(lstrResult, true, bHumanReadable);
1134
1135        // Concatenate the criterion list as the command result
1136        CUtility::asString(lstrResult, strResult);
1137
1138        return CCommandHandler::ESucceeded;
1139    }
1140}
1141
1142/// Domains
1143CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1144{
1145    (void)remoteCommand;
1146
1147    getConfigurableDomains()->listDomains(strResult);
1148
1149    return CCommandHandler::ESucceeded;
1150}
1151
1152CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::createDomainCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1153{
1154    return createDomain(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1155}
1156
1157CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteDomainCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1158{
1159    return deleteDomain(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1160}
1161
1162CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteAllDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1163{
1164    (void)remoteCommand;
1165
1166    return deleteAllDomains(strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1167}
1168
1169CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::renameDomainCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1170{
1171    return renameDomain(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ?
1172        CCommandHandler::EDone : CCommandHandler::EFailed;
1173}
1174
1175CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setSequenceAwarenessCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1176{
1177    // Set property
1178    bool bSequenceAware;
1179
1180    if (remoteCommand.getArgument(1) == "true") {
1181
1182        bSequenceAware = true;
1183
1184    } else if (remoteCommand.getArgument(1) == "false") {
1185
1186        bSequenceAware = false;
1187
1188    } else {
1189        // Show usage
1190        return CCommandHandler::EShowUsage;
1191    }
1192
1193    return setSequenceAwareness(remoteCommand.getArgument(0), bSequenceAware, strResult) ?
1194        CCommandHandler::EDone : CCommandHandler::EFailed;
1195}
1196
1197CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getSequenceAwarenessCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1198{
1199    // Get property
1200    bool bSequenceAware;
1201
1202    if (!getSequenceAwareness(remoteCommand.getArgument(0), bSequenceAware, strResult)) {
1203
1204        return CCommandHandler::EFailed;
1205    }
1206
1207    strResult = bSequenceAware ? "true" : "false";
1208
1209    return CCommandHandler::ESucceeded;
1210}
1211
1212CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1213{
1214    return getConfigurableDomains()->listDomainElements(remoteCommand.getArgument(0), strResult) ? CCommandHandler::ESucceeded : CCommandHandler::EFailed;
1215}
1216
1217CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::addElementCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1218{
1219    return addConfigurableElementToDomain(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1220}
1221
1222CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::removeElementCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1223{
1224    return removeConfigurableElementFromDomain(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1225}
1226
1227CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::splitDomainCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1228{
1229    return split(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1230}
1231
1232/// Configurations
1233CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConfigurationsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1234{
1235    return getConstConfigurableDomains()->listConfigurations(remoteCommand.getArgument(0), strResult) ? CCommandHandler::ESucceeded : CCommandHandler::EFailed;
1236}
1237
1238CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1239{
1240    (void)remoteCommand;
1241
1242    // Dummy error context
1243    string strError;
1244    CErrorContext errorContext(strError);
1245
1246    // Dump
1247    getConstConfigurableDomains()->dumpContent(strResult, errorContext);
1248
1249    return CCommandHandler::ESucceeded;
1250}
1251
1252CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::createConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1253{
1254    return createConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1255}
1256
1257CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1258{
1259    return deleteConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1260}
1261
1262CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::renameConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1263{
1264    return renameConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
1265            remoteCommand.getArgument(2), strResult) ?
1266        CCommandHandler::EDone : CCommandHandler::EFailed;
1267}
1268
1269CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::saveConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1270{
1271    return saveConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1272}
1273
1274CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::restoreConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1275{
1276    list<string> lstrResult;
1277    if (!restoreConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), lstrResult)) {
1278        //Concatenate the error list as the command result
1279        CUtility::asString(lstrResult, strResult);
1280
1281        return  CCommandHandler::EFailed;
1282    }
1283    return CCommandHandler::EDone;
1284}
1285
1286CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setElementSequenceCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1287{
1288    // Build configurable element path list
1289    std::vector<string> astrNewElementSequence;
1290
1291    uint32_t uiArgument;
1292
1293    for (uiArgument = 2; uiArgument < remoteCommand.getArgumentCount(); uiArgument++) {
1294
1295        astrNewElementSequence.push_back(remoteCommand.getArgument(uiArgument));
1296    }
1297
1298    // Delegate to configurable domains
1299    return setElementSequence(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
1300            astrNewElementSequence, strResult) ?
1301        CCommandHandler::EDone : CCommandHandler::EFailed;
1302}
1303
1304CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSequenceCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1305{
1306    // Delegate to configurable domains
1307    return getConfigurableDomains()->getElementSequence(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::ESucceeded : CCommandHandler::EFailed;
1308}
1309
1310CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setRuleCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1311{
1312    // Delegate to configurable domains
1313    return setApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
1314            remoteCommand.packArguments(2, remoteCommand.getArgumentCount() - 2), strResult) ?
1315        CCommandHandler::EDone : CCommandHandler::EFailed;
1316}
1317
1318CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::clearRuleCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1319{
1320    // Delegate to configurable domains
1321    return clearApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
1322            strResult) ?
1323        CCommandHandler::EDone : CCommandHandler::EFailed;
1324}
1325
1326CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getRuleCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1327{
1328    // Delegate to configurable domains
1329    return getApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1),
1330            strResult) ?
1331        CCommandHandler::ESucceeded : CCommandHandler::EFailed;
1332}
1333
1334/// Elements/Parameters
1335CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1336{
1337    CElementLocator elementLocator(getSystemClass(), false);
1338
1339    CElement* pLocatedElement = NULL;
1340
1341    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {
1342
1343        return CCommandHandler::EFailed;
1344    }
1345
1346    strResult = string("\n");
1347
1348    if (!pLocatedElement) {
1349
1350        // List from root folder
1351
1352        // Return system class qualified name
1353        pLocatedElement = getSystemClass();
1354    }
1355
1356    // Return sub-elements
1357    strResult += pLocatedElement->listQualifiedPaths(false);
1358
1359    return CCommandHandler::ESucceeded;
1360}
1361
1362/// Elements/Parameters
1363CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listParametersCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1364{
1365    CElementLocator elementLocator(getSystemClass(), false);
1366
1367    CElement* pLocatedElement = NULL;
1368
1369    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {
1370
1371        return CCommandHandler::EFailed;
1372    }
1373
1374    strResult = string("\n");
1375
1376    if (!pLocatedElement) {
1377
1378        // List from root folder
1379
1380        // Return system class qualified name
1381        pLocatedElement = getSystemClass();
1382    }
1383
1384    // Return sub-elements
1385    strResult += pLocatedElement->listQualifiedPaths(true);
1386
1387    return CCommandHandler::ESucceeded;
1388}
1389
1390CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpElementCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1391{
1392    CElementLocator elementLocator(getSystemClass());
1393
1394    CElement* pLocatedElement = NULL;
1395
1396    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {
1397
1398        return CCommandHandler::EFailed;
1399    }
1400
1401    string strError;
1402
1403    CParameterAccessContext parameterAccessContext(strError, _pMainParameterBlackboard, _bValueSpaceIsRaw, _bOutputRawFormatIsHex);
1404
1405    // Dump elements
1406    pLocatedElement->dumpContent(strResult, parameterAccessContext);
1407
1408    return CCommandHandler::ESucceeded;
1409}
1410
1411CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSizeCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1412{
1413    CElementLocator elementLocator(getSystemClass());
1414
1415    CElement* pLocatedElement = NULL;
1416
1417    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {
1418
1419        return CCommandHandler::EFailed;
1420    }
1421
1422    // Converted to actual sizable element
1423    const CConfigurableElement* pConfigurableElement = static_cast<const CConfigurableElement*>(pLocatedElement);
1424
1425    // Get size as string
1426    strResult = pConfigurableElement->getFootprintAsString();
1427
1428    return CCommandHandler::ESucceeded;
1429}
1430
1431CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showPropertiesCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1432{
1433    CElementLocator elementLocator(getSystemClass());
1434
1435    CElement* pLocatedElement = NULL;
1436
1437    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {
1438
1439        return CCommandHandler::EFailed;
1440    }
1441
1442    // Convert element
1443    const CConfigurableElement* pConfigurableElement = static_cast<const CConfigurableElement*>(pLocatedElement);
1444
1445    // Return element properties
1446    pConfigurableElement->showProperties(strResult);
1447
1448    return CCommandHandler::ESucceeded;
1449}
1450
1451CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getParameterCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1452{
1453    string strValue;
1454
1455    if (!accessParameterValue(remoteCommand.getArgument(0), strValue, false, strResult)) {
1456
1457        return CCommandHandler::EFailed;
1458    }
1459    // Succeeded
1460    strResult = strValue;
1461
1462    return CCommandHandler::ESucceeded;
1463}
1464
1465CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setParameterCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1466{
1467    // Get value to set
1468    string strValue = remoteCommand.packArguments(1, remoteCommand.getArgumentCount() - 1);
1469
1470    return accessParameterValue(remoteCommand.getArgument(0), strValue, true, strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1471}
1472
1473CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listBelongingDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1474{
1475    CElementLocator elementLocator(getSystemClass());
1476
1477    CElement* pLocatedElement = NULL;
1478
1479    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {
1480
1481        return CCommandHandler::EFailed;
1482    }
1483
1484    // Convert element
1485    const CConfigurableElement* pConfigurableElement = static_cast<const CConfigurableElement*>(pLocatedElement);
1486
1487    // Return element belonging domains
1488    pConfigurableElement->listBelongingDomains(strResult);
1489
1490    return CCommandHandler::ESucceeded;
1491}
1492
1493CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1494{
1495    CElementLocator elementLocator(getSystemClass());
1496
1497    CElement* pLocatedElement = NULL;
1498
1499    if (!elementLocator.locate(remoteCommand.getArgument(0), &pLocatedElement, strResult)) {
1500
1501        return CCommandHandler::EFailed;
1502    }
1503
1504    // Convert element
1505    const CConfigurableElement* pConfigurableElement = static_cast<const CConfigurableElement*>(pLocatedElement);
1506
1507    // Return element belonging domains
1508    pConfigurableElement->listAssociatedDomains(strResult);
1509
1510    return CCommandHandler::ESucceeded;
1511}
1512
1513CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1514{
1515    (void)remoteCommand;
1516
1517    getConfigurableDomains()->listAssociatedElements(strResult);
1518
1519    return CCommandHandler::ESucceeded;
1520}
1521
1522CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConflictingElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1523{
1524    (void)remoteCommand;
1525
1526    getConfigurableDomains()->listConflictingElements(strResult);
1527
1528    return CCommandHandler::ESucceeded;
1529}
1530
1531CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listRogueElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1532{
1533    (void)remoteCommand;
1534
1535    getSystemClass()->listRogueElements(strResult);
1536
1537    return CCommandHandler::ESucceeded;
1538}
1539
1540CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getConfigurationParameterCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1541{
1542    string strOutputValue;
1543    string strError;
1544
1545    if (!accessConfigurationValue(remoteCommand.getArgument(0), remoteCommand.getArgument(1), remoteCommand.getArgument(2), strOutputValue, false, strError)) {
1546
1547        strResult = strError;
1548        return CCommandHandler::EFailed;
1549    }
1550    // Succeeded
1551    strResult = strOutputValue;
1552
1553    return CCommandHandler::ESucceeded;
1554}
1555
1556CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setConfigurationParameterCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1557{
1558    // Get value to set
1559    string strValue = remoteCommand.packArguments(3, remoteCommand.getArgumentCount() - 3);
1560
1561    bool bSuccess = accessConfigurationValue(remoteCommand.getArgument(0),
1562                                            remoteCommand.getArgument(1),
1563                                            remoteCommand.getArgument(2),
1564                                            strValue, true, strResult);
1565
1566    return bSuccess ? CCommandHandler::EDone : CCommandHandler::EFailed;
1567}
1568
1569CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showMappingCommandProcess(
1570        const IRemoteCommand& remoteCommand,
1571        string& strResult)
1572{
1573    if (!getParameterMapping(remoteCommand.getArgument(0), strResult)) {
1574
1575        return CCommandHandler::EFailed;
1576    }
1577
1578    return CCommandHandler::ESucceeded;
1579}
1580
1581/// Settings Import/Export
1582CParameterMgr::CCommandHandler::CommandStatus
1583        CParameterMgr::exportDomainsXMLCommandProcess(
1584                const IRemoteCommand& remoteCommand, string& strResult)
1585{
1586    string strFileName = remoteCommand.getArgument(0);
1587    return exportDomainsXml(strFileName, false, true, strResult) ?
1588            CCommandHandler::EDone : CCommandHandler::EFailed;
1589}
1590
1591CParameterMgr::CCommandHandler::CommandStatus
1592        CParameterMgr::importDomainsXMLCommandProcess(
1593                const IRemoteCommand& remoteCommand, string& strResult)
1594{
1595    return importDomainsXml(remoteCommand.getArgument(0), false, true, strResult) ?
1596            CCommandHandler::EDone : CCommandHandler::EFailed;
1597}
1598
1599CParameterMgr::CCommandHandler::CommandStatus
1600        CParameterMgr::exportDomainsWithSettingsXMLCommandProcess(
1601                const IRemoteCommand& remoteCommand, string& strResult)
1602{
1603    string strFileName = remoteCommand.getArgument(0);
1604    return exportDomainsXml(strFileName, true, true, strResult) ?
1605            CCommandHandler::EDone : CCommandHandler::EFailed;
1606}
1607
1608CParameterMgr::CCommandHandler::CommandStatus
1609        CParameterMgr::exportDomainWithSettingsXMLCommandProcess(
1610                const IRemoteCommand& remoteCommand, string& result)
1611{
1612    string domainName = remoteCommand.getArgument(0);
1613    string fileName = remoteCommand.getArgument(1);
1614    return exportSingleDomainXml(fileName, domainName, true, true, result) ?
1615            CCommandHandler::EDone : CCommandHandler::EFailed;
1616}
1617
1618CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importDomainsWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1619{
1620    return importDomainsXml(remoteCommand.getArgument(0), true, true, strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1621}
1622
1623CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importDomainWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1624{
1625    bool bOverwrite = false;
1626
1627    // Look for optional arguments
1628    if (remoteCommand.getArgumentCount() > 1) {
1629
1630        if (remoteCommand.getArgument(1) == "overwrite") {
1631
1632            bOverwrite = true;
1633        } else {
1634            // Show usage
1635            return CCommandHandler::EShowUsage;
1636        }
1637    }
1638
1639    return importSingleDomainXml(remoteCommand.getArgument(0), bOverwrite, true, true, strResult) ?
1640        CCommandHandler::EDone : CCommandHandler::EFailed;
1641}
1642
1643CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::exportSettingsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1644{
1645    return exportDomainsBinary(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1646}
1647
1648CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importSettingsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult)
1649{
1650    return importDomainsBinary(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed;
1651}
1652
1653CParameterMgr::CCommandHandler::CommandStatus
1654        CParameterMgr::getDomainsWithSettingsXMLCommandProcess(
1655                const IRemoteCommand& remoteCommand, string& strResult)
1656{
1657    (void)remoteCommand;
1658
1659    if (!exportDomainsXml(strResult, true, false, strResult)) {
1660
1661        return CCommandHandler::EFailed;
1662    }
1663    // Succeeded
1664    return CCommandHandler::ESucceeded;
1665}
1666
1667CParameterMgr::CCommandHandler::CommandStatus
1668        CParameterMgr::getDomainWithSettingsXMLCommandProcess(
1669                const IRemoteCommand& remoteCommand, string& strResult)
1670{
1671    string strDomainName = remoteCommand.getArgument(0);
1672
1673    return exportSingleDomainXml(strResult, strDomainName, true, false, strResult) ?
1674        CCommandHandler::ESucceeded : CCommandHandler::EFailed;
1675}
1676
1677CParameterMgr::CCommandHandler::CommandStatus
1678        CParameterMgr::setDomainsWithSettingsXMLCommandProcess(
1679                const IRemoteCommand& remoteCommand, string& strResult)
1680{
1681    return importDomainsXml(remoteCommand.getArgument(0), true, false, strResult) ?
1682            CCommandHandler::EDone : CCommandHandler::EFailed;
1683}
1684
1685CParameterMgr::CCommandHandler::CommandStatus
1686        CParameterMgr::setDomainWithSettingsXMLCommandProcess(
1687                const IRemoteCommand& remoteCommand, string& result)
1688{
1689    bool overwrite = false;
1690
1691    if (remoteCommand.getArgumentCount() > 1) {
1692
1693        if (remoteCommand.getArgument(1) == "overwrite") {
1694
1695            overwrite = true;
1696        } else {
1697            // Show usage
1698            return CCommandHandler::EShowUsage;
1699        }
1700    }
1701
1702    return importSingleDomainXml(remoteCommand.getArgument(0), overwrite, true, false, result) ?
1703        CCommandHandler::EDone : CCommandHandler::EFailed;
1704}
1705
1706CParameterMgr::CCommandHandler::CommandStatus
1707        CParameterMgr::getSystemClassXMLCommandProcess(
1708                const IRemoteCommand& remoteCommand, string& strResult)
1709{
1710    (void)remoteCommand;
1711
1712    // Get Root element where to export from
1713    const CSystemClass* pSystemClass = getSystemClass();
1714
1715    if (!exportElementToXMLString(pSystemClass, pSystemClass->getKind(), strResult)) {
1716
1717        return CCommandHandler::EFailed;
1718    }
1719    // Succeeded
1720    return CCommandHandler::ESucceeded;
1721}
1722
1723// User set/get parameters in main BlackBoard
1724bool CParameterMgr::accessParameterValue(const string& strPath, string& strValue, bool bSet, string& strError)
1725{
1726    // Forbid write access when not in TuningMode
1727    if (bSet && !checkTuningModeOn(strError)) {
1728
1729        return false;
1730    }
1731
1732    // Define context
1733    CParameterAccessContext parameterAccessContext(strError, _pMainParameterBlackboard, _bValueSpaceIsRaw, _bOutputRawFormatIsHex);
1734
1735    // Activate the auto synchronization with the hardware
1736    if (bSet) {
1737
1738        parameterAccessContext.setAutoSync(_bAutoSyncOn);
1739    }
1740
1741    return accessValue(parameterAccessContext, strPath, strValue, bSet, strError);
1742}
1743
1744// User get parameter mapping
1745bool CParameterMgr::getParameterMapping(const string& strPath, string& strResult) const
1746{
1747    CPathNavigator pathNavigator(strPath);
1748
1749    // Nagivate through system class
1750    if (!pathNavigator.navigateThrough(getConstSystemClass()->getName(), strResult)) {
1751
1752        return false;
1753    }
1754
1755    // Get the ConfigurableElement corresponding to strPath
1756    const CConfigurableElement* pConfigurableElement = getConfigurableElement(strPath, strResult);
1757    if (!pConfigurableElement) {
1758
1759        return false;
1760    }
1761
1762    // Find the list of the ancestors of the current ConfigurableElement that have a mapping
1763    list<const CConfigurableElement*> configurableElementPath;
1764    pConfigurableElement->getListOfElementsWithMapping(configurableElementPath);
1765
1766    // Get the Subsystem containing the ConfigurableElement
1767    const CSubsystem* pSubsystem = pConfigurableElement->getBelongingSubsystem();
1768    if (!pSubsystem) {
1769
1770        strResult = "Unable to find the Subsystem containing the parameter";
1771        return false;
1772    }
1773
1774    // Fetch the mapping corresponding to the ConfigurableElement
1775    strResult = pSubsystem->getMapping(configurableElementPath);
1776
1777    return true;
1778}
1779
1780// User set/get parameters in specific Configuration BlackBoard
1781bool CParameterMgr::accessConfigurationValue(const string& strDomain, const string& strConfiguration, const string& strPath, string& strValue, bool bSet, string& strError)
1782{
1783    CElementLocator elementLocator(getSystemClass());
1784
1785    CElement* pLocatedElement = NULL;
1786
1787    if (!elementLocator.locate(strPath, &pLocatedElement, strError)) {
1788
1789        return false;
1790    }
1791
1792    // Convert element
1793    const CConfigurableElement* pConfigurableElement = static_cast<const CConfigurableElement*>(pLocatedElement);
1794
1795    // Get the Configuration blackboard and the Base Offset of the configurable element in this blackboard
1796    uint32_t uiBaseOffset;
1797    bool bIsLastApplied;
1798
1799    CParameterBlackboard* pConfigurationBlackboard = getConstConfigurableDomains()->findConfigurationBlackboard(strDomain, strConfiguration, pConfigurableElement, uiBaseOffset, bIsLastApplied, strError);
1800
1801    if (!pConfigurationBlackboard) {
1802
1803        return false;
1804    }
1805
1806    log_info("Element %s in Domain %s, offset: %d, base offset: %d", strPath.c_str(), strDomain.c_str(), pConfigurableElement->getOffset(), uiBaseOffset);
1807
1808    /// Update the Configuration Blackboard
1809
1810    // Define Configuration context using Base Offset and keep Auto Sync off to prevent access to HW
1811    CParameterAccessContext parameterAccessContext(strError, pConfigurationBlackboard, _bValueSpaceIsRaw, _bOutputRawFormatIsHex, uiBaseOffset);
1812
1813    // Deactivate the auto synchronization with the hardware during the Configuration Blackboard
1814    // access (only Main Blackboard shall be synchronized, Configurations Blackboards are copied
1815    // into the Main Blackboard each time a configuration is restored but they are not synchronized
1816    // directly).
1817    if (bSet) {
1818
1819        parameterAccessContext.setAutoSync(false);
1820    }
1821
1822    // Access Value in the Configuration Blackboard
1823    if (!accessValue(parameterAccessContext, strPath, strValue, bSet, strError)) {
1824
1825        return false;
1826    }
1827
1828    /// If the Configuration is the last one applied, update the Main Blackboard as well
1829
1830    if (bIsLastApplied) {
1831
1832        // Define Main context
1833        parameterAccessContext.setParameterBlackboard(_pMainParameterBlackboard);
1834
1835        // Activate the auto synchronization with the hardware
1836        if (bSet) {
1837
1838            parameterAccessContext.setAutoSync(_bAutoSyncOn);
1839        }
1840
1841        // Access Value in the Main Blackboard
1842        return accessValue(parameterAccessContext, strPath, strValue, bSet, strError);
1843    }
1844
1845    return true;
1846}
1847
1848// User set/get parameters
1849bool CParameterMgr::accessValue(CParameterAccessContext& parameterAccessContext, const string& strPath, string& strValue, bool bSet, string& strError)
1850{
1851    // Lock state
1852    CAutoLock autoLock(&_blackboardMutex);
1853
1854    CPathNavigator pathNavigator(strPath);
1855
1856    // Nagivate through system class
1857    if (!pathNavigator.navigateThrough(getConstSystemClass()->getName(), strError)) {
1858
1859        parameterAccessContext.setError(strError);
1860
1861        return false;
1862    }
1863
1864    // Do the get
1865    return getConstSystemClass()->accessValue(pathNavigator, strValue, bSet, parameterAccessContext);
1866}
1867
1868// Tuning mode
1869bool CParameterMgr::setTuningMode(bool bOn, string& strError)
1870{
1871    // Tuning allowed?
1872    if (bOn && !getConstFrameworkConfiguration()->isTuningAllowed()) {
1873
1874        strError = "Tuning prohibited";
1875
1876        return false;
1877    }
1878    // Lock state
1879    CAutoLock autoLock(&_blackboardMutex);
1880
1881    // Warn domains about exiting tuning mode
1882    if (!bOn && _bTuningModeIsOn) {
1883
1884        // Ensure application of currently selected configurations
1885        // Force-apply configurations
1886        doApplyConfigurations(true);
1887
1888        // Turn auto sync back on
1889        _bAutoSyncOn = true;
1890    }
1891
1892    // Store
1893    _bTuningModeIsOn = bOn;
1894
1895    return true;
1896}
1897
1898bool CParameterMgr::tuningModeOn() const
1899{
1900    return _bTuningModeIsOn;
1901}
1902
1903// Current value space for user set/get value interpretation
1904void CParameterMgr::setValueSpace(bool bIsRaw)
1905{
1906    _bValueSpaceIsRaw = bIsRaw;
1907}
1908
1909bool CParameterMgr::valueSpaceIsRaw()
1910{
1911    return _bValueSpaceIsRaw;
1912}
1913
1914// Current Output Raw Format for user get value interpretation
1915void CParameterMgr::setOutputRawFormat(bool bIsHex)
1916{
1917    _bOutputRawFormatIsHex = bIsHex;
1918}
1919
1920bool CParameterMgr::outputRawFormatIsHex()
1921{
1922    return _bOutputRawFormatIsHex;
1923}
1924
1925/// Sync
1926// Automatic hardware synchronization control (during tuning session)
1927bool CParameterMgr::setAutoSync(bool bAutoSyncOn, string& strError)
1928{
1929    // Check tuning mode
1930    if (!checkTuningModeOn(strError)) {
1931
1932        return false;
1933    }
1934    // Warn domains about turning auto sync back on
1935    if (bAutoSyncOn && !_bAutoSyncOn) {
1936
1937        // Do the synchronization at system class level (could be optimized by keeping track of all modified parameters)
1938        if (!sync(strError)) {
1939
1940            return false;
1941        }
1942    }
1943
1944    // Set Auto sync
1945    _bAutoSyncOn = bAutoSyncOn;
1946
1947    return true;
1948}
1949
1950bool CParameterMgr::autoSyncOn() const
1951{
1952    return _bAutoSyncOn;
1953}
1954
1955// Manual hardware synchronization control (during tuning session)
1956bool CParameterMgr::sync(string& strError)
1957{
1958    // Check tuning mode
1959    if (!checkTuningModeOn(strError)) {
1960
1961        return false;
1962    }
1963    // Warn domains about turning auto sync back on
1964    if (_bAutoSyncOn) {
1965
1966        strError = "Feature unavailable when Auto Sync is on";
1967
1968        return false;
1969    }
1970
1971    // Get syncer set
1972    CSyncerSet syncerSet;
1973    // ... from system class
1974    getConstSystemClass()->fillSyncerSet(syncerSet);
1975
1976    // Sync
1977    list<string> lstrError;
1978    if (! syncerSet.sync(*_pMainParameterBlackboard, false, &lstrError)){
1979
1980        CUtility::asString(lstrError, strError);
1981        return false;
1982    };
1983
1984    return true;
1985}
1986
1987// Configuration/Domains handling
1988bool CParameterMgr::createDomain(const string& strName, string& strError)
1989{
1990    // Check tuning mode
1991    if (!checkTuningModeOn(strError)) {
1992
1993        return false;
1994    }
1995
1996    // Delegate to configurable domains
1997    return getConfigurableDomains()->createDomain(strName, strError);
1998}
1999
2000bool CParameterMgr::deleteDomain(const string& strName, string& strError)
2001{
2002    // Check tuning mode
2003    if (!checkTuningModeOn(strError)) {
2004
2005        return false;
2006    }
2007
2008    // Delegate to configurable domains
2009    return getConfigurableDomains()->deleteDomain(strName, strError);
2010}
2011
2012bool CParameterMgr::renameDomain(const string& strName, const string& strNewName, string& strError)
2013{
2014    // Delegate to configurable domains
2015    return getConfigurableDomains()->renameDomain(strName, strNewName, strError);
2016}
2017
2018bool CParameterMgr::deleteAllDomains(string& strError)
2019{
2020    // Check tuning mode
2021    if (!checkTuningModeOn(strError)) {
2022
2023        return false;
2024    }
2025
2026    // Delegate to configurable domains
2027    getConfigurableDomains()->deleteAllDomains();
2028
2029    return true;
2030}
2031
2032bool CParameterMgr::setSequenceAwareness(const string& strName, bool bSequenceAware, string& strResult)
2033{
2034    // Check tuning mode
2035    if (!checkTuningModeOn(strResult)) {
2036
2037        return false;
2038    }
2039
2040    return getConfigurableDomains()->setSequenceAwareness(strName, bSequenceAware, strResult);
2041}
2042
2043bool CParameterMgr::getSequenceAwareness(const string& strName, bool& bSequenceAware,
2044                                         string& strResult)
2045{
2046    return getConfigurableDomains()->getSequenceAwareness(strName, bSequenceAware, strResult);
2047}
2048
2049bool CParameterMgr::createConfiguration(const string& strDomain, const string& strConfiguration, string& strError)
2050{
2051    // Check tuning mode
2052    if (!checkTuningModeOn(strError)) {
2053
2054        return false;
2055    }
2056
2057    // Delegate to configurable domains
2058    return getConfigurableDomains()->createConfiguration(strDomain, strConfiguration, _pMainParameterBlackboard, strError);
2059}
2060bool CParameterMgr::renameConfiguration(const string& strDomain, const string& strConfiguration,
2061                                        const string& strNewConfiguration, string& strError)
2062{
2063    return getConfigurableDomains()->renameConfiguration(strDomain, strConfiguration,
2064            strNewConfiguration, strError);
2065}
2066
2067bool CParameterMgr::deleteConfiguration(const string& strDomain, const string& strConfiguration, string& strError)
2068{
2069    // Check tuning mode
2070    if (!checkTuningModeOn(strError)) {
2071
2072        return false;
2073    }
2074
2075    // Delegate to configurable domains
2076    return getConfigurableDomains()->deleteConfiguration(strDomain, strConfiguration, strError);
2077}
2078
2079bool CParameterMgr::restoreConfiguration(const string& strDomain, const string& strConfiguration, list<string>& lstrError)
2080{
2081    string strError;
2082    // Check tuning mode
2083    if (!checkTuningModeOn(strError)) {
2084
2085        lstrError.push_back(strError);
2086        return false;
2087    }
2088
2089    // Delegate to configurable domains
2090    return getConstConfigurableDomains()->restoreConfiguration(strDomain, strConfiguration, _pMainParameterBlackboard, _bAutoSyncOn, lstrError);
2091}
2092
2093bool CParameterMgr::saveConfiguration(const string& strDomain, const string& strConfiguration, string& strError)
2094{
2095    // Check tuning mode
2096    if (!checkTuningModeOn(strError)) {
2097
2098        return false;
2099    }
2100
2101    // Delegate to configurable domains
2102    return getConfigurableDomains()->saveConfiguration(strDomain, strConfiguration, _pMainParameterBlackboard, strError);
2103}
2104
2105// Configurable element - domain association
2106bool CParameterMgr::addConfigurableElementToDomain(const string& strDomain, const string& strConfigurableElementPath, string& strError)
2107{
2108    // Check tuning mode
2109    if (!checkTuningModeOn(strError)) {
2110
2111        return false;
2112    }
2113
2114    CElementLocator elementLocator(getSystemClass());
2115
2116    CElement* pLocatedElement = NULL;
2117
2118    if (!elementLocator.locate(strConfigurableElementPath, &pLocatedElement, strError)) {
2119
2120        return false;
2121    }
2122
2123    // Convert element
2124    CConfigurableElement* pConfigurableElement = static_cast<CConfigurableElement*>(pLocatedElement);
2125
2126    // Delegate
2127    return getConfigurableDomains()->addConfigurableElementToDomain(strDomain, pConfigurableElement, _pMainParameterBlackboard, strError);
2128}
2129
2130bool CParameterMgr::removeConfigurableElementFromDomain(const string& strDomain, const string& strConfigurableElementPath, string& strError)
2131{
2132    // Check tuning mode
2133    if (!checkTuningModeOn(strError)) {
2134
2135        return false;
2136    }
2137
2138    CElementLocator elementLocator(getSystemClass());
2139
2140    CElement* pLocatedElement = NULL;
2141
2142    if (!elementLocator.locate(strConfigurableElementPath, &pLocatedElement, strError)) {
2143
2144        return false;
2145    }
2146
2147    // Convert element
2148    CConfigurableElement* pConfigurableElement = static_cast<CConfigurableElement*>(pLocatedElement);
2149
2150    // Delegate
2151    return getConfigurableDomains()->removeConfigurableElementFromDomain(strDomain, pConfigurableElement, strError);
2152}
2153
2154bool CParameterMgr::split(const string& strDomain, const string& strConfigurableElementPath, string& strError)
2155{
2156    // Check tuning mode
2157    if (!checkTuningModeOn(strError)) {
2158
2159        return false;
2160    }
2161
2162    CElementLocator elementLocator(getSystemClass());
2163
2164    CElement* pLocatedElement = NULL;
2165
2166    if (!elementLocator.locate(strConfigurableElementPath, &pLocatedElement, strError)) {
2167
2168        return false;
2169    }
2170
2171    // Convert element
2172    CConfigurableElement* pConfigurableElement = static_cast<CConfigurableElement*>(pLocatedElement);
2173
2174    // Delegate
2175    return getConfigurableDomains()->split(strDomain, pConfigurableElement, strError);
2176}
2177
2178bool CParameterMgr::setElementSequence(const string& strDomain, const string& strConfiguration,
2179                                       const std::vector<string>& astrNewElementSequence,
2180                                       string& strError)
2181{
2182    // Check tuning mode
2183    if (!checkTuningModeOn(strError)) {
2184
2185        return false;
2186    }
2187
2188    return getConfigurableDomains()->setElementSequence(strDomain, strConfiguration,
2189            astrNewElementSequence, strError);
2190}
2191
2192bool CParameterMgr::getApplicationRule(const string& strDomain, const string& strConfiguration,
2193                                       string& strResult)
2194{
2195    return getConfigurableDomains()->getApplicationRule(strDomain, strConfiguration, strResult);
2196}
2197
2198bool CParameterMgr::setApplicationRule(const string& strDomain, const string& strConfiguration,
2199                                       const string& strApplicationRule, string& strError)
2200{
2201    return getConfigurableDomains()->setApplicationRule(strDomain, strConfiguration,
2202            strApplicationRule, getConstSelectionCriteria()->getSelectionCriteriaDefinition(),
2203            strError);
2204}
2205
2206bool CParameterMgr::clearApplicationRule(const string& strDomain, const string& strConfiguration,
2207                                         string& strError)
2208{
2209    return getConfigurableDomains()->clearApplicationRule(strDomain, strConfiguration, strError);
2210}
2211
2212bool CParameterMgr::importDomainsXml(const string& xmlSource, bool withSettings,
2213                                     bool fromFile, string& errorMsg)
2214{
2215    // Check tuning mode
2216    if (!checkTuningModeOn(errorMsg)) {
2217
2218        return false;
2219    }
2220
2221    CAutoLog autoLog(this, string("Importing domains from ") +
2222            (fromFile ? ("\"" + xmlSource + "\"") : "a user-provided buffer"));
2223
2224    // Root element
2225    CConfigurableDomains* pConfigurableDomains = getConfigurableDomains();
2226
2227    bool importSuccess = wrapLegacyXmlImport(xmlSource, fromFile, withSettings,
2228                                             *pConfigurableDomains, "SystemClassName", errorMsg);
2229
2230    if (importSuccess) {
2231
2232        // Validate domains after XML import
2233        pConfigurableDomains->validate(_pMainParameterBlackboard);
2234    }
2235
2236    return importSuccess;
2237}
2238
2239bool CParameterMgr::importSingleDomainXml(const string& xmlSource, bool overwrite,
2240                                          bool withSettings, bool fromFile, string& errorMsg)
2241{
2242    if (!checkTuningModeOn(errorMsg)) {
2243
2244        return false;
2245    }
2246
2247    CAutoLog autoLog(this, string("Importing a single domain from ") +
2248            (fromFile ? ("\"" + xmlSource + "\"") : "a user-provided buffer"));
2249
2250    // We initialize the domain with an empty name but since we have set the isDomainStandalone
2251    // context, the name will be retrieved during de-serialization
2252    std::auto_ptr<CConfigurableDomain> standaloneDomain(new CConfigurableDomain());
2253
2254    if (!wrapLegacyXmlImport(xmlSource, fromFile, withSettings, *standaloneDomain, "", errorMsg)) {
2255        return false;
2256    }
2257
2258    if (!getConfigurableDomains()->addDomain(*standaloneDomain, overwrite, errorMsg)) {
2259        return false;
2260    }
2261
2262    // ownership has been transfered to the ConfigurableDomains object
2263    standaloneDomain.release();
2264    return true;
2265}
2266
2267bool CParameterMgr::wrapLegacyXmlImport(const string& xmlSource, bool fromFile,
2268                                        bool withSettings, CElement& element,
2269                                        const string& nameAttributeName, string& errorMsg)
2270{
2271    CXmlDomainImportContext xmlDomainImportContext(errorMsg, withSettings, *getSystemClass());
2272
2273    // Selection criteria definition for rule creation
2274    xmlDomainImportContext.setSelectionCriteriaDefinition(
2275            getConstSelectionCriteria()->getSelectionCriteriaDefinition());
2276
2277    // It doesn't make sense to resolve XIncludes on an imported file because
2278    // we can't reliably decide of a "base url"
2279    _xmlDoc *doc = CXmlDocSource::mkXmlDoc(xmlSource, fromFile, false, errorMsg);
2280    if (doc == NULL) {
2281        return false;
2282    }
2283
2284    return xmlParse(xmlDomainImportContext, &element, doc, "", EParameterConfigurationLibrary, nameAttributeName);
2285}
2286
2287bool CParameterMgr::serializeElement(std::ostream& output,
2288                                     CXmlSerializingContext& xmlSerializingContext,
2289                                     const CElement& element) const
2290{
2291    if (!output.good()) {
2292        xmlSerializingContext.setError("Can't write XML: the output is in a bad state.");
2293        return false;
2294    }
2295
2296    // Get Schema file associated to root element
2297    string xmlSchemaFilePath = _strSchemaFolderLocation + "/" +
2298                                  element.getKind() + ".xsd";
2299
2300    // Use a doc source by loading data from instantiated Configurable Domains
2301    CXmlMemoryDocSource memorySource(&element, _bValidateSchemasOnStart,
2302                                     element.getKind(),
2303                                     xmlSchemaFilePath,
2304                                     "parameter-framework",
2305                                     getVersion());
2306
2307    // Use a doc sink to write the doc data in a stream
2308    CXmlStreamDocSink sink(output);
2309
2310    bool processSuccess = sink.process(memorySource, xmlSerializingContext);
2311
2312    return processSuccess;
2313}
2314
2315bool CParameterMgr::exportDomainsXml(string& xmlDest, bool withSettings, bool toFile,
2316                                     string& errorMsg) const
2317{
2318    CAutoLog autoLog(this, string("Exporting domains to ") +
2319            (toFile ? ("\"" + xmlDest + "\"") : " a user-provided buffer"));
2320
2321    const CConfigurableDomains* configurableDomains = getConstConfigurableDomains();
2322
2323    return wrapLegacyXmlExport(xmlDest, toFile, withSettings, *configurableDomains, errorMsg);
2324}
2325
2326bool CParameterMgr::exportSingleDomainXml(string& xmlDest, const string& domainName,
2327                                          bool withSettings, bool toFile, string& errorMsg) const
2328{
2329    CAutoLog autoLog(this, string("Exporting single domain '") + domainName + "' to " +
2330            (toFile ? ("\"" + xmlDest + "\"") : " a user-provided buffer"));
2331
2332    // Element to be serialized
2333    const CConfigurableDomain* requestedDomain =
2334        getConstConfigurableDomains()->findConfigurableDomain(domainName, errorMsg);
2335
2336    if (requestedDomain == NULL) {
2337        return false;
2338    }
2339
2340    return wrapLegacyXmlExport(xmlDest, toFile, withSettings, *requestedDomain, errorMsg);
2341}
2342
2343bool CParameterMgr::wrapLegacyXmlExport(string& xmlDest, bool toFile, bool withSettings,
2344                                        const CElement& element, string& errorMsg) const
2345{
2346    CXmlDomainExportContext context(errorMsg, withSettings, _bValueSpaceIsRaw,
2347                                    _bOutputRawFormatIsHex);
2348
2349    if (toFile) {
2350        return wrapLegacyXmlExportToFile(xmlDest, element, context);
2351    } else {
2352        return wrapLegacyXmlExportToString(xmlDest, element, context);
2353    }
2354}
2355
2356bool CParameterMgr::wrapLegacyXmlExportToFile(string& xmlDest,
2357                                              const CElement& element,
2358                                              CXmlDomainExportContext &context) const
2359{
2360    std::ofstream output(xmlDest.c_str());
2361
2362    if (output.fail()) {
2363        context.setError("Failed to open \"" + xmlDest + "\" for writing.");
2364        return false;
2365    }
2366
2367    return serializeElement(output, context, element);
2368
2369}
2370
2371bool CParameterMgr::wrapLegacyXmlExportToString(string& xmlDest,
2372                                                const CElement& element,
2373                                                CXmlDomainExportContext &context) const
2374{
2375    std::ostringstream output;
2376
2377    if (!serializeElement(output, context, element)) {
2378        return false;
2379    }
2380
2381    xmlDest = output.str();
2382
2383    return true;
2384}
2385
2386// Binary Import/Export
2387bool CParameterMgr::importDomainsBinary(const string& strFileName, string& strError)
2388{
2389    // Check tuning mode
2390    if (!checkTuningModeOn(strError)) {
2391
2392        return false;
2393    }
2394
2395    CAutoLog autoLog(this, string("Importing domains from binary file \"") + strFileName + "\"");
2396    // Root element
2397    CConfigurableDomains* pConfigurableDomains = getConfigurableDomains();
2398
2399    // Serialize in
2400    return pConfigurableDomains->serializeSettings(strFileName, false, _uiStructureChecksum, strError);
2401}
2402
2403bool CParameterMgr::exportDomainsBinary(const string& strFileName, string& strError)
2404{
2405    CAutoLog autoLog(this, string("Exporting domains to binary file \"") + strFileName + "\"");
2406    // Root element
2407    CConfigurableDomains* pConfigurableDomains = getConfigurableDomains();
2408
2409    // Serialize out
2410    return pConfigurableDomains->serializeSettings(strFileName, true, _uiStructureChecksum, strError);
2411}
2412
2413// For tuning, check we're in tuning mode
2414bool CParameterMgr::checkTuningModeOn(string& strError) const
2415{
2416    // Tuning Mode on?
2417    if (!_bTuningModeIsOn) {
2418
2419        strError = "Tuning Mode must be on";
2420
2421        return false;
2422    }
2423    return true;
2424}
2425
2426// Tuning mutex dynamic parameter handling
2427pthread_mutex_t* CParameterMgr::getBlackboardMutex()
2428{
2429    return &_blackboardMutex;
2430}
2431
2432// Blackboard reference (dynamic parameter handling)
2433CParameterBlackboard* CParameterMgr::getParameterBlackboard()
2434{
2435    return _pMainParameterBlackboard;
2436}
2437
2438// Dynamic creation library feeding
2439void CParameterMgr::feedElementLibraries()
2440{
2441    // Global Configuration handling
2442    CElementLibrary* pFrameworkConfigurationLibrary = new CElementLibrary;
2443
2444    pFrameworkConfigurationLibrary->addElementBuilder("ParameterFrameworkConfiguration", new TElementBuilderTemplate<CParameterFrameworkConfiguration>());
2445    pFrameworkConfigurationLibrary->addElementBuilder("SubsystemPlugins", new TKindElementBuilderTemplate<CSubsystemPlugins>());
2446    pFrameworkConfigurationLibrary->addElementBuilder("Location", new TKindElementBuilderTemplate<CPluginLocation>());
2447    pFrameworkConfigurationLibrary->addElementBuilder("StructureDescriptionFileLocation", new TKindElementBuilderTemplate<CFrameworkConfigurationLocation>());
2448    pFrameworkConfigurationLibrary->addElementBuilder("SettingsConfiguration", new TKindElementBuilderTemplate<CFrameworkConfigurationGroup>());
2449    pFrameworkConfigurationLibrary->addElementBuilder("ConfigurableDomainsFileLocation", new TKindElementBuilderTemplate<CFrameworkConfigurationLocation>());
2450    pFrameworkConfigurationLibrary->addElementBuilder("BinarySettingsFileLocation", new TKindElementBuilderTemplate<CFrameworkConfigurationLocation>());
2451
2452    _pElementLibrarySet->addElementLibrary(pFrameworkConfigurationLibrary);
2453
2454    // Parameter creation
2455    CElementLibrary* pParameterCreationLibrary = new CElementLibrary;
2456
2457    pParameterCreationLibrary->addElementBuilder("Subsystem", new CSubsystemElementBuilder(getSystemClass()->getSubsystemLibrary()));
2458    pParameterCreationLibrary->addElementBuilder("ComponentType", new TNamedElementBuilderTemplate<CComponentType>());
2459    pParameterCreationLibrary->addElementBuilder("Component", new TNamedElementBuilderTemplate<CComponentInstance>());
2460    pParameterCreationLibrary->addElementBuilder("BitParameter", new TNamedElementBuilderTemplate<CBitParameterType>());
2461    pParameterCreationLibrary->addElementBuilder("BitParameterBlock", new TNamedElementBuilderTemplate<CBitParameterBlockType>());
2462    pParameterCreationLibrary->addElementBuilder("StringParameter", new TNamedElementBuilderTemplate<CStringParameterType>());
2463    pParameterCreationLibrary->addElementBuilder("ParameterBlock", new TNamedElementBuilderTemplate<CParameterBlockType>());
2464    pParameterCreationLibrary->addElementBuilder("BooleanParameter", new TNamedElementBuilderTemplate<CBooleanParameterType>());
2465    pParameterCreationLibrary->addElementBuilder("IntegerParameter", new TNamedElementBuilderTemplate<CIntegerParameterType>());
2466    pParameterCreationLibrary->addElementBuilder("LinearAdaptation", new TElementBuilderTemplate<CLinearParameterAdaptation>());
2467    pParameterCreationLibrary->addElementBuilder("LogarithmicAdaptation", new TElementBuilderTemplate<CLogarithmicParameterAdaptation>());
2468    pParameterCreationLibrary->addElementBuilder("EnumParameter", new TNamedElementBuilderTemplate<CEnumParameterType>());
2469    pParameterCreationLibrary->addElementBuilder("ValuePair", new TElementBuilderTemplate<CEnumValuePair>());
2470    pParameterCreationLibrary->addElementBuilder("FixedPointParameter", new TNamedElementBuilderTemplate<CFixedPointParameterType>());
2471    pParameterCreationLibrary->addElementBuilder("SubsystemInclude", new CFileIncluderElementBuilder(_bValidateSchemasOnStart));
2472
2473    _pElementLibrarySet->addElementLibrary(pParameterCreationLibrary);
2474
2475    // Parameter Configuration Domains creation
2476    CElementLibrary* pParameterConfigurationLibrary = new CElementLibrary;
2477
2478    pParameterConfigurationLibrary->addElementBuilder("ConfigurableDomain", new TElementBuilderTemplate<CConfigurableDomain>());
2479    pParameterConfigurationLibrary->addElementBuilder("Configuration", new TNamedElementBuilderTemplate<CDomainConfiguration>());
2480    pParameterConfigurationLibrary->addElementBuilder("CompoundRule", new TElementBuilderTemplate<CCompoundRule>());
2481    pParameterConfigurationLibrary->addElementBuilder("SelectionCriterionRule", new TElementBuilderTemplate<CSelectionCriterionRule>());
2482
2483    _pElementLibrarySet->addElementLibrary(pParameterConfigurationLibrary);
2484}
2485
2486bool CParameterMgr::getForceNoRemoteInterface() const
2487{
2488    return _bForceNoRemoteInterface;
2489}
2490
2491void CParameterMgr::setForceNoRemoteInterface(bool bForceNoRemoteInterface)
2492{
2493    _bForceNoRemoteInterface = bForceNoRemoteInterface;
2494}
2495
2496// Remote Processor Server connection handling
2497bool CParameterMgr::handleRemoteProcessingInterface(string& strError)
2498{
2499    CAutoLog autoLog(this, "Handling remote processing interface");
2500
2501    if (_bForceNoRemoteInterface) {
2502        // The user requested not to start the remote interface
2503        return true;
2504    }
2505
2506    // Start server if tuning allowed
2507    if (getConstFrameworkConfiguration()->isTuningAllowed()) {
2508
2509        log_info("Loading remote processor library");
2510
2511        // Load library
2512        _pvLibRemoteProcessorHandle = dlopen("libremote-processor.so", RTLD_NOW);
2513
2514        if (!_pvLibRemoteProcessorHandle) {
2515
2516            // Return error
2517            const char* pcError = dlerror();
2518
2519            if (pcError) {
2520
2521                strError = pcError;
2522            } else {
2523
2524                strError = "Unable to load libremote-processor.so library";
2525            }
2526
2527            return false;
2528        }
2529
2530        CreateRemoteProcessorServer pfnCreateRemoteProcessorServer = (CreateRemoteProcessorServer)dlsym(_pvLibRemoteProcessorHandle, "createRemoteProcessorServer");
2531
2532        if (!pfnCreateRemoteProcessorServer) {
2533
2534            strError = "libremote-process.so does not contain createRemoteProcessorServer symbol.";
2535
2536            return false;
2537        }
2538
2539        // Create server
2540        _pRemoteProcessorServer = pfnCreateRemoteProcessorServer(getConstFrameworkConfiguration()->getServerPort(), _pCommandHandler);
2541
2542        log_info("Starting remote processor server on port %d", getConstFrameworkConfiguration()->getServerPort());
2543        // Start
2544        if (!_pRemoteProcessorServer->start(strError)) {
2545
2546            ostringstream oss;
2547            oss << "ParameterMgr: Unable to start remote processor server on port "
2548                << getConstFrameworkConfiguration()->getServerPort();
2549            strError = oss.str() + ": " + strError;
2550
2551            return false;
2552        }
2553    }
2554
2555    return true;
2556}
2557
2558// Children typwise access
2559CParameterFrameworkConfiguration* CParameterMgr::getFrameworkConfiguration()
2560{
2561    return static_cast<CParameterFrameworkConfiguration*>(getChild(EFrameworkConfiguration));
2562}
2563
2564const CParameterFrameworkConfiguration* CParameterMgr::getConstFrameworkConfiguration()
2565{
2566    return getFrameworkConfiguration();
2567}
2568
2569CSelectionCriteria* CParameterMgr::getSelectionCriteria()
2570{
2571    return static_cast<CSelectionCriteria*>(getChild(ESelectionCriteria));
2572}
2573
2574const CSelectionCriteria* CParameterMgr::getConstSelectionCriteria()
2575{
2576    return static_cast<const CSelectionCriteria*>(getChild(ESelectionCriteria));
2577}
2578
2579CSystemClass* CParameterMgr::getSystemClass()
2580{
2581    return static_cast<CSystemClass*>(getChild(ESystemClass));
2582}
2583
2584const CSystemClass* CParameterMgr::getConstSystemClass() const
2585{
2586    return static_cast<const CSystemClass*>(getChild(ESystemClass));
2587}
2588
2589// Configurable Domains
2590CConfigurableDomains* CParameterMgr::getConfigurableDomains()
2591{
2592    return static_cast<CConfigurableDomains*>(getChild(EConfigurableDomains));
2593}
2594
2595const CConfigurableDomains* CParameterMgr::getConstConfigurableDomains()
2596{
2597    return static_cast<const CConfigurableDomains*>(getChild(EConfigurableDomains));
2598}
2599
2600const CConfigurableDomains* CParameterMgr::getConstConfigurableDomains() const
2601{
2602    return static_cast<const CConfigurableDomains*>(getChild(EConfigurableDomains));
2603}
2604
2605// Apply configurations
2606void CParameterMgr::doApplyConfigurations(bool bForce)
2607{
2608    CSyncerSet syncerSet;
2609
2610    // Check subsystems that need resync
2611    getSystemClass()->checkForSubsystemsToResync(syncerSet);
2612
2613    // Ensure application of currently selected configurations
2614    getConfigurableDomains()->apply(_pMainParameterBlackboard, syncerSet, bForce);
2615
2616    // Reset the modified status of the current criteria to indicate that a new configuration has been applied
2617    getSelectionCriteria()->resetModifiedStatus();
2618}
2619
2620// Export to XML string
2621bool CParameterMgr::exportElementToXMLString(const IXmlSource* pXmlSource,
2622                                             const string& strRootElementType,
2623                                             string& strResult) const
2624{
2625    string strError;
2626
2627    CXmlSerializingContext xmlSerializingContext(strError);
2628
2629    // Use a doc source by loading data from instantiated Configurable Domains
2630    CXmlMemoryDocSource memorySource(pXmlSource, false, strRootElementType);
2631
2632    // Use a doc sink that write the doc data in a string
2633    ostringstream output;
2634    CXmlStreamDocSink streamSink(output);
2635
2636    // Do the export
2637    bool bProcessSuccess = streamSink.process(memorySource, xmlSerializingContext);
2638
2639    if (bProcessSuccess) {
2640        strResult = output.str();
2641    } else {
2642        strResult = strError;
2643    }
2644
2645    return bProcessSuccess;
2646}
2647