/* * Copyright (c) 2011-2014, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation and/or * other materials provided with the distribution. * * 3. Neither the name of the copyright holder nor the names of its contributors * may be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #pragma once #include #include #include #include #include "RemoteCommandHandlerTemplate.h" #include "PathNavigator.h" #include "SelectionCriterionType.h" #include "SelectionCriterion.h" #include "Element.h" #include "XmlDocSink.h" #include "XmlDocSource.h" #include "XmlDomainExportContext.h" #include #include #include class CElementLibrarySet; class CSubsystemLibrary; class CSystemClass; class CSelectionCriteria; class CParameterFrameworkConfiguration; class CSystemClassConfiguration; class CParameterBlackboard; class CConfigurableDomains; class IRemoteProcessorServerInterface; class CParameterHandle; class CSubsystemPlugins; class CParameterAccessContext; class CConfigurableElement; class CParameterMgr : private CElement { enum ChildElement { EFrameworkConfiguration, ESelectionCriteria, ESystemClass, EConfigurableDomains }; enum ElementLibrary { EFrameworkConfigurationLibrary, EParameterCreationLibrary, EParameterConfigurationLibrary }; // Remote command parsers typedef TRemoteCommandHandlerTemplate CCommandHandler; typedef CCommandHandler::CommandStatus (CParameterMgr::*RemoteCommandParser)(const IRemoteCommand& remoteCommand, std::string& strResult); // Parser descriptions struct SRemoteCommandParserItem { const char* _pcCommandName; CParameterMgr::RemoteCommandParser _pfnParser; uint32_t _uiMinArgumentCount; const char* _pcHelp; const char* _pcDescription; }; // Version static const uint32_t guiEditionMajor = 2; static const uint32_t guiEditionMinor = 6; static const uint32_t guiRevision = 0; // Parameter handle friendship friend class CParameterHandle; public: // Logger interface class ILogger { public: virtual void log(bool bIsWarning, const std::string& strLog) = 0; protected: virtual ~ILogger() {} }; // Construction CParameterMgr(const std::string& strConfigurationFilePath); virtual ~CParameterMgr(); // Logging void setLogger(ILogger* pLogger); /** Load plugins, structures and settings from the config file given. * * @param[out] strError is a std::string describing the error if an error occurred * undefined otherwise. * * @return true if no error occurred, false otherwise. */ bool load(std::string& strError); // Selection Criteria CSelectionCriterionType* createSelectionCriterionType(bool bIsInclusive); CSelectionCriterion* createSelectionCriterion(const std::string& strName, const CSelectionCriterionType* pSelectionCriterionType); // Selection criterion retrieval CSelectionCriterion* getSelectionCriterion(const std::string& strName); // Configuration application void applyConfigurations(); /** * Returns the CConfigurableElement corresponding to the path given in argument. * * @param[in] strPath A std::string representing a path to an element. * @param[out] strError Error message * * @return A const pointer to the corresponding CConfigurableElement. * On error, NULL is returned and the error is explained in strError. */ const CConfigurableElement* getConfigurableElement(const std::string& strPath, std::string& strError) const; // Dynamic parameter handling CParameterHandle* createParameterHandle(const std::string& strPath, std::string& strError); /** Is the remote interface forcefully disabled ? */ bool getForceNoRemoteInterface() const; /** * Forcefully disable the remote interface or cancel this policy * * @param[in] bForceNoRemoteInterface disable the remote interface if true. */ void setForceNoRemoteInterface(bool bForceNoRemoteInterface); /** Should start fail in case of missing subsystems. * * @param[in] bFail: If set to true, parameterMgr start will fail on missing subsystems. * If set to false, missing subsystems will fallback on virtual subsystem. */ void setFailureOnMissingSubsystem(bool bFail); /** Would start fail in case of missing subsystems. * * @return true if the subsystem will fail on missing subsystem, false otherwise. */ bool getFailureOnMissingSubsystem() const; /** Should start fail in failed settings load. * * @param[in] bFail: If set to true, parameterMgr start will fail on failed settings load. * If set to false, failed settings load will be ignored. */ void setFailureOnFailedSettingsLoad(bool bFail); /** Would start fail in case of failed settings load. * * @return failure on failed settings load policy state. */ bool getFailureOnFailedSettingsLoad(); /** Get the path to the directory containing the XML Schemas * * @returns the directory containing the XML Schemas */ const std::string& getSchemaFolderLocation() const; /** Override the directory containing the XML Schemas * * @param[in] strSchemaFolderLocation directory containing the XML Schemas */ void setSchemaFolderLocation(const std::string& strSchemaFolderLocation); /** Should .xml files be validated on start ? * * @param[in] bValidate: * If set to true, parameterMgr will report an error * when being unable to validate .xml files * If set to false, no .xml/xsd validation will happen * (default behaviour) * * @return false if unable to set, true otherwise. */ void setValidateSchemasOnStart(bool bValidate); /** Would .xml files be validated on start? * * @return areSchemasValidated */ bool getValidateSchemasOnStart() const; //////////// Tuning ///////////// // Tuning mode bool setTuningMode(bool bOn, std::string& strError); bool tuningModeOn() const; // Current value space for user set/get value interpretation void setValueSpace(bool bIsRaw); bool valueSpaceIsRaw(); // Current Output Raw Format for user get value interpretation void setOutputRawFormat(bool bIsHex); bool outputRawFormatIsHex(); // Automatic hardware synchronization control (during tuning session) bool setAutoSync(bool bAutoSyncOn, std::string& strError); bool autoSyncOn() const; bool sync(std::string& strError); // User set/get parameters bool accessParameterValue(const std::string& strPath, std::string& strValue, bool bSet, std::string& strError); /** * Returns the element mapping corresponding to the path given in parameter. * * @param[in] strPath Path of an element * @param[out] strValue A sting containing the mapping * * @return true if a mapping was found for this element */ bool getParameterMapping(const std::string& strPath, std::string& strValue) const; bool accessConfigurationValue(const std::string &strDomain, const std::string &stConfiguration, const std::string& strPath, std::string& strValue, bool bSet, std::string& strError); ////////// Configuration/Domains handling ////////////// // Creation/Deletion bool createDomain(const std::string& strName, std::string& strError); bool renameDomain(const std::string& strName, const std::string& strNewName, std::string& strError); bool deleteDomain(const std::string& strName, std::string& strError); bool deleteAllDomains(std::string& strError); bool setSequenceAwareness(const std::string& strName, bool bSequenceAware, std::string& strResult); bool getSequenceAwareness(const std::string& strName, bool& bSequenceAware, std::string& strResult); bool createConfiguration(const std::string& strDomain, const std::string& strConfiguration, std::string& strError); bool deleteConfiguration(const std::string& strDomain, const std::string& strConfiguration, std::string& strError); bool renameConfiguration(const std::string& strDomain, const std::string& strConfiguration, const std::string& strNewConfiguration, std::string& strError); // Save/Restore bool restoreConfiguration(const std::string& strDomain, const std::string& strConfiguration, std::list& strError); bool saveConfiguration(const std::string& strDomain, const std::string& strConfiguration, std::string& strError); // Configurable element - domain association bool addConfigurableElementToDomain(const std::string& strDomain, const std::string& strConfigurableElementPath, std::string& strError); bool removeConfigurableElementFromDomain(const std::string& strDomain, const std::string& strConfigurableElementPath, std::string& strError); bool split(const std::string& strDomain, const std::string& strConfigurableElementPath, std::string& strError); bool setElementSequence(const std::string& strDomain, const std::string& strConfiguration, const std::vector& astrNewElementSequence, std::string& strError); bool getApplicationRule(const std::string& strDomain, const std::string& strConfiguration, std::string& strResult); bool setApplicationRule(const std::string& strDomain, const std::string& strConfiguration, const std::string& strApplicationRule, std::string& strError); bool clearApplicationRule(const std::string& strDomain, const std::string& strConfiguration, std::string& strError); /** * Method that imports Configurable Domains from an Xml source. * * @param[in] xmlSource a std::string containing an xml description or a path to an xml file * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description * @param[in] fromFile a boolean that determines if the source is an xml description in * xmlSource or contained in a file. In that case xmlSource is just the file path. * @param[out] errorMsg is used as the error output * * @return false if any error occures */ bool importDomainsXml(const std::string& xmlSource, bool withSettings, bool fromFile, std::string& errorMsg); /** * Method that imports a single Configurable Domain from an Xml source. * * @param[in] xmlSource a string containing an xml description or a path to an xml file * @param[in] overwrite when importing an existing domain, allow * overwriting or return an error * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description * @param[in] fromFile a boolean that determines if the source is an xml description in * xmlSource or contained in a file. In that case xmlSource is just the file path. * @param[out] errorMsg is used as the error output * * @return false if any error occurs */ bool importSingleDomainXml(const std::string& xmlSource, bool overwrite, bool withSettings, bool fromFile, std::string& errorMsg); /** * Method that exports Configurable Domains to an Xml destination. * * @param[in,out] xmlDest a string containing an xml description or a path to an xml file * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description * @param[in] toFile a boolean that determines if the destination is an xml description in * xmlDest or contained in a file. In that case xmlDest is just the file path. * @param[out] errorMsg is used as the error output * * @return false if any error occurs, true otherwise. */ bool exportDomainsXml(std::string& xmlDest, bool withSettings, bool toFile, std::string& errorMsg) const; /** * Method that exports a given Configurable Domain to an Xml destination. * * @param[in,out] xmlDest a string containing an xml description or a path to an xml file * @param[in] domainName the name of the domain to be exported * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description * @param[in] toFile a boolean that determines if the destination is an xml description in * xmlDest or contained in a file. In that case xmlDest is just the file path. * @param[out] errorMsg is used as the error output * * @return false if any error occurs, true otherwise. */ bool exportSingleDomainXml(std::string& xmlDest, const std::string& domainName, bool withSettings, bool toFile, std::string& errorMsg) const; // Binary Import/Export bool importDomainsBinary(const std::string& strFileName, std::string& strError); bool exportDomainsBinary(const std::string& strFileName, std::string& strError); /** * Method that exports an Xml description of the passed element into a string * * @param[in] pXmlSource The source element to export * @param[in] strRootElementType The XML root element name of the exported instance document * @param[out] strResult contains the xml description or the error description in case false is returned * * @return true for success, false if any error occurs during the creation of the xml description (validation or encoding) */ bool exportElementToXMLString(const IXmlSource* pXmlSource, const std::string& strRootElementType, std::string& strResult) const; // CElement virtual std::string getKind() const; private: CParameterMgr(const CParameterMgr&); CParameterMgr& operator=(const CParameterMgr&); // Init virtual bool init(std::string& strError); // Logging (done by root) virtual void doLog(bool bIsWarning, const std::string& strLog) const; virtual void nestLog() const; virtual void unnestLog() const; // Version std::string getVersion() const; ////////////////:: Remote command parsers /// Version CCommandHandler::CommandStatus versionCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Status CCommandHandler::CommandStatus statusCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Tuning Mode CCommandHandler::CommandStatus setTuningModeCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getTuningModeCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Value Space CCommandHandler::CommandStatus setValueSpaceCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getValueSpaceCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Output Raw Format CCommandHandler::CommandStatus setOutputRawFormatCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getOutputRawFormatCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Sync CCommandHandler::CommandStatus setAutoSyncCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getAutoSyncCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus syncCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Criteria CCommandHandler::CommandStatus listCriteriaCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Domains CCommandHandler::CommandStatus listDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus createDomainCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus deleteDomainCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus deleteAllDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus renameDomainCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus setSequenceAwarenessCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getSequenceAwarenessCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus listDomainElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus addElementCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus removeElementCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus splitDomainCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Configurations CCommandHandler::CommandStatus listConfigurationsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus dumpDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus createConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus deleteConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus renameConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus saveConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus restoreConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus setElementSequenceCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getElementSequenceCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus setRuleCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus clearRuleCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getRuleCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Elements/Parameters CCommandHandler::CommandStatus listElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus listParametersCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus dumpElementCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getElementSizeCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus showPropertiesCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getParameterCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus setParameterCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus getConfigurationParameterCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus setConfigurationParameterCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus listBelongingDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus listAssociatedDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus showMappingCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Browse CCommandHandler::CommandStatus listAssociatedElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus listConflictingElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus listRogueElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Settings Import/Export CCommandHandler::CommandStatus exportDomainsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus importDomainsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus exportDomainsWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus importDomainsWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /** * Command handler method for exportDomainWithSettingsXML command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] result a std::string containing the result of the command * * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ CCommandHandler::CommandStatus exportDomainWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& result); CCommandHandler::CommandStatus importDomainWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus exportSettingsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); CCommandHandler::CommandStatus importSettingsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /** * Command handler method for getDomainsWithSettings command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] strResult a std::string containing the result of the command * * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ CCommandHandler::CommandStatus getDomainsWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& strResult); /** * Command handler method for getDomainWithSettings command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] strResult a string containing the result of the command * * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ CCommandHandler::CommandStatus getDomainWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& strResult); /** * Command handler method for setDomainsWithSettings command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] strResult a std::string containing the result of the command * * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ CCommandHandler::CommandStatus setDomainsWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& strResult); /** * Command handler method for setDomainWithSettings command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] result a std::string containing the result of the command * * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ CCommandHandler::CommandStatus setDomainWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& result); /** * Command handler method for getSystemClass command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] strResult a std::string containing the result of the command * * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ CCommandHandler::CommandStatus getSystemClassXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& strResult); // Max command usage length, use for formatting void setMaxCommandUsageLength(); // For tuning, check we're in tuning mode bool checkTuningModeOn(std::string& strError) const; // Blackboard (dynamic parameter handling) pthread_mutex_t* getBlackboardMutex(); // Blackboard reference (dynamic parameter handling) CParameterBlackboard* getParameterBlackboard(); // Parameter access bool accessValue(CParameterAccessContext& parameterAccessContext, const std::string& strPath, std::string& strValue, bool bSet, std::string& strError); bool doSetValue(const std::string& strPath, const std::string& strValue, bool bRawValueSpace, bool bDynamicAccess, std::string& strError) const; bool doGetValue(const std::string& strPath, std::string& strValue, bool bRawValueSpace, bool bHexOutputRawFormat, bool bDynamicAccess, std::string& strError) const; // Framework global configuration loading bool loadFrameworkConfiguration(std::string& strError); // System class Structure loading bool loadStructure(std::string& strError); // System class Structure loading bool loadSettings(std::string& strError); bool loadSettingsFromConfigFile(std::string& strError); /** Parse an XML stream into an element * * @param[in] elementSerializingContext serializing context * @param[out] pRootElement the receiving element * @param[in] input the input XML stream * @param[in] strXmlFolder the folder containing the XML input file (if applicable) or "" * @param[in] eElementLibrary which element library to be used * @param[in] strNameAttributeName the name of the element's XML "name" attribute * * @returns true if parsing succeeded, false otherwise */ bool xmlParse(CXmlElementSerializingContext& elementSerializingContext, CElement* pRootElement, _xmlDoc* doc, const std::string& strXmlFolder, ElementLibrary eElementLibrary, const std::string& strNameAttributeName = "Name"); /** Wrapper for converting public APIs semantics to internal API * * Public APIs have a string argument that can either contain: * - a path to an XML file or; * - an actual XML document. * They also have a boolean argument specifying which of the two cases it * is. * * Instead, the internal APIs only take an std::istream argument. This * method opens the file as a stream if applicable or simply wrap the * string in a stream. It then passes the stream to the internal methods. * * @param[in] xmlSource the XML source (either a path or an actual xml * document) * @param[in] fromFile specifies whether xmlSource is a path or an * actual XML document * @param[in] withSettings if false, only import the configurations * applicability rules; if true, also import their settings * @param[out] element the receiving element * @param[in] nameAttributeName the name of the element's XML "name" * attribute * @param[out] errorMsg string used as output for any error message * * @returns true if the import succeeded, false otherwise */ bool wrapLegacyXmlImport(const std::string& xmlSource, bool fromFile, bool withSettings, CElement& element, const std::string& nameAttributeName, std::string& errorMsg); /** * Export an element object to an Xml destination. * * * @param[out] output the stream to output the XML to * @param[in] xmlSerializingContext the serializing context * @param[in] element object to be serialized. * * @return false if any error occurs, true otherwise. */ bool serializeElement(std::ostream& output, CXmlSerializingContext& xmlSerializingContext, const CElement& element) const; /** Wrapper for converting public APIs semantics to internal API * * Public APIs have a string argument that can either: * - contain a path to an XML file or; * - receive an actual XML document. * They also have a boolean argument specifying which of the two cases it * is. * * Instead, the internal APIs only take an std::ostream argument. This * method opens the file as a stream if applicable or simply wrap the * string in a stream. It then passes the stream to the internal methods. * * @param[in] xmlDest the XML sink (either a path or any string that * will be filled) * @param[in] toFile specifies whether xmlSource is a path or a * string that will receive an actual XML document * @param[in] withSettings if false, only export the configurations * applicability rules; if true, also export their settings * @param[out] element the element to be exported * @param[out] errorMsg string used as output for any error message * * @returns true if the export succeeded, false otherwise */ bool wrapLegacyXmlExport(std::string& xmlDest, bool toFile, bool withSettings, const CElement& element, std::string& errorMsg) const; /** Wrapper for converting public APIs semantics to internal API * * @see wrapLegacyXmlExport */ bool wrapLegacyXmlExportToFile(std::string& xmlDest, const CElement& element, CXmlDomainExportContext &context) const; /** Wrapper for converting public APIs semantics to internal API * * @see wrapLegacyXmlExport */ bool wrapLegacyXmlExportToString(std::string& xmlDest, const CElement& element, CXmlDomainExportContext &context) const; // Framework Configuration CParameterFrameworkConfiguration* getFrameworkConfiguration(); const CParameterFrameworkConfiguration* getConstFrameworkConfiguration(); // Selection Criteria CSelectionCriteria* getSelectionCriteria(); const CSelectionCriteria* getConstSelectionCriteria(); // System Class CSystemClass* getSystemClass(); const CSystemClass* getConstSystemClass() const; // Configurable Domains CConfigurableDomains* getConfigurableDomains(); const CConfigurableDomains* getConstConfigurableDomains(); const CConfigurableDomains* getConstConfigurableDomains() const; // Apply configurations void doApplyConfigurations(bool bForce); // Dynamic object creation libraries feeding void feedElementLibraries(); // Remote Processor Server connection handling bool handleRemoteProcessingInterface(std::string& strError); // Tuning bool _bTuningModeIsOn; // Value Space bool _bValueSpaceIsRaw; // Output Raw Format bool _bOutputRawFormatIsHex; // Automatic synchronization to HW during Tuning session bool _bAutoSyncOn; // Current Parameter Settings CParameterBlackboard* _pMainParameterBlackboard; // Dynamic object creation CElementLibrarySet* _pElementLibrarySet; // XML parsing, object creation handling std::string _strXmlConfigurationFilePath; // Configuration file path std::string _strXmlConfigurationFolderPath; // Root folder for configuration file std::string _strSchemaFolderLocation; // Place where schemas stand // Subsystem plugin location const CSubsystemPlugins* _pSubsystemPlugins; /** * Remote processor library handle */ void* _pvLibRemoteProcessorHandle; // Whole system structure checksum uint8_t _uiStructureChecksum; // Command Handler CCommandHandler* _pCommandHandler; // Remote Processor Server IRemoteProcessorServerInterface* _pRemoteProcessorServer; // Parser description array static const SRemoteCommandParserItem gastRemoteCommandParserItems[]; // Parser description array size static const uint32_t guiNbRemoteCommandParserItems; // Maximum command usage length uint32_t _uiMaxCommandUsageLength; // Blackboard access mutex pthread_mutex_t _blackboardMutex; // Logging ILogger* _pLogger; mutable uint32_t _uiLogDepth; /** If set to false, the remote interface won't be started no matter what. * If set to true - the default - it has no impact on the policy for * starting the remote interface. */ bool _bForceNoRemoteInterface; /** If set to true, missing subsystem will abort parameterMgr start. * If set to false, missing subsystem will fallback on virtual subsystem. */ bool _bFailOnMissingSubsystem; /** If set to true, unparsable or discording domains will abort parameterMgr start. * If set to false, unparsable or discording domains * will continue the parameterMgr start with no domains. */ bool _bFailOnFailedSettingsLoad; /** * If set to true, parameterMgr will report an error * when being unable to validate .xml files * If set to false, no .xml/xsd validation will happen (default behaviour) */ bool _bValidateSchemasOnStart; };