| /* |
| * 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 <pthread.h> |
| #include <map> |
| #include <vector> |
| #include <list> |
| #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 <string> |
| #include <ostream> |
| #include <istream> |
| |
| 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<CParameterMgr> 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<std::string>& 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<std::string>& 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; |
| }; |
| |
