/* * Copyright (c) 2011-2016, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation and/or * other materials provided with the distribution. * * 3. Neither the name of the copyright holder nor the names of its contributors * may be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #pragma once #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 "Results.h" #include "ElementHandle.h" #include #include #include #include #include #include class CElementLibrarySet; class CSubsystemLibrary; class CSystemClass; class CSelectionCriteria; class CParameterFrameworkConfiguration; 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 }; // Parameter handle friendship friend class ElementHandle; public: // Construction CParameterMgr(const std::string &strConfigurationFilePath, core::log::ILogger &logger); virtual ~CParameterMgr(); /** 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); // Remote command parsers using CommandHandler = std::unique_ptr>; /** Create and return a command handler for this ParameterMgr instance * * @returns a Command Handler */ CommandHandler createCommandHandler(); // 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(); /** const version of getConfigurableElement */ const CConfigurableElement *getConfigurableElement(const std::string &strPath, std::string &strError) const; /** 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. */ CConfigurableElement *getConfigurableElement(const std::string &strPath, std::string &strError); // Dynamic parameter handling CParameterHandle *createParameterHandle(const std::string &strPath, std::string &strError); /** Creates a handle to a configurable element. * * The returned object is owned by the client who is responsible to delete it. * * @param[in] path A string representing a path to a configurable element. * @param[out] error On error: an human readable error message * On success: undefined * * @return An element handle on success * nullptr on error */ ElementHandle *createElementHandle(const std::string &path, std::string &error); /** 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() const; /** Get the XML Schemas URI * * @returns the XML Schemas URI */ const std::string &getSchemaUri() const; /** Override the XML Schemas URI * * @param[in] schemaUri XML Schemas URI */ void setSchemaUri(const std::string &schemaUri); /** 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 ///////////// /** * Activate / deactivate the tuning mode. * * @param[in] bOn true if tuning mode activation is requested, false for desactivation * @param[out] strError human readable error * @return true if request is successful, false if the Parameter Manager is already in the mode * requested or in case of error. * If false, strError is set with the associated human readable error. */ 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); /** Restore a configuration * * @param[in] strDomain the domain name * @param[in] strConfiguration the configuration name * @param[out] errors errors encountered during restoration * @return true if success false otherwise */ bool restoreConfiguration(const std::string &strDomain, const std::string &strConfiguration, core::Results &errors); 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; /** * 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[in] xmlSerializingContext the context to use for serialization * Is an rvalue as it must be destructed after this function * call to set the error. * Additionally, using it for an other serialization would * override the error. * @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, CXmlSerializingContext &&xmlSerializingContext, 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); // Version std::string getVersion() const; // This using is here for internal reasons: CommandHandler is public and is // a unique_ptr but we want the type that's inside. And for legacy reason // because that's the original name before a rework; this directive avoids // renaming a lot of stuff. using CCommandHandler = CommandHandler::element_type; using RemoteCommandParser = CCommandHandler::CommandStatus (CParameterMgr::*)( const IRemoteCommand &remoteCommand, std::string &strResult); // Parser descriptions struct SRemoteCommandParserItem { const char *_pcCommandName; CParameterMgr::RemoteCommandParser _pfnParser; size_t _minArgumentCount; const char *_pcHelp; const char *_pcDescription; }; ////////////////:: 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 getElementStructureXMLCommandProcess( const IRemoteCommand &remoteCommand, std::string &strResult); CCommandHandler::CommandStatus getElementBytesCommandProcess( const IRemoteCommand &remoteCommand, std::string &strResult); CCommandHandler::CommandStatus setElementBytesCommandProcess( const IRemoteCommand &remoteCommand, std::string &strResult); CCommandHandler::CommandStatus getElementXMLCommandProcess(const IRemoteCommand &remoteCommand, std::string &strResult); CCommandHandler::CommandStatus setElementXMLCommandProcess(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); /** * 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) std::mutex &getBlackboardMutex(); // Blackboard reference (dynamic parameter handling) CParameterBlackboard *getParameterBlackboard(); // Parameter access bool accessValue(CParameterAccessContext ¶meterAccessContext, 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); /** Load required subsystems * * @param[out] error error description if there is one * @return true if succeed false otherwise */ bool loadSubsystems(std::string &error); // System class Structure loading bool loadStructure(std::string &strError); // System class Structure loading bool loadSettings(std::string &strError); bool loadSettingsFromConfigFile(std::string &strError); /** Get settings from a configurable element in binary format. * * @param[in] element configurable element. * @param[out] settings current element settings (in mainblackboard) in binary format * * @return true on success, false on error */ void getSettingsAsBytes(const CConfigurableElement &element, std::vector &settings) const; /** Assign settings to a configurable element in binary format. * * @param[in] element configurable element. * @param[in] settings the settings as byte array (binary). * @param[out] error error message filled in case of error * * @return true in case of success, false oherwise, in which case error is filled with error * message. */ bool setSettingsAsBytes(const CConfigurableElement &element, const std::vector &settings, std::string &error); /** Assign settings to a configurable element in XML format. * * @param[in] configurableElement The element to set. * @param[in] settings The settings to set. * @param[out] error human readable error message filled in case of error, * undefined in case of success. * @return true in case of success, false otherwise */ bool setSettingsAsXML(CConfigurableElement *configurableElement, const std::string &settings, std::string &error); /** Get settings from a configurable element in XML format. * * @param[in] configurableElement The element to get settings from. * @param[out] result on success: the exported setttings in XML * on error: human readable error message * * @return true in case of success, false otherwise. */ bool getSettingsAsXML(const CConfigurableElement *configurableElement, std::string &result) const; /** 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] baseUri the XML input file URI or "" * @param[in] eElementLibrary which element library to be used * @param[in] replace Should the element be overridden or modified in place * @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 &baseUri, ElementLibrary eElementLibrary, bool replace = true, 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 isRemoteInterfaceRequired(); bool handleRemoteProcessingInterface(std::string &strError); /** Log the result of a function * * @param[in] isSuccess indicates if the previous function has succeed * @param[in] result function provided result string * @return isSuccess parameter */ bool logResult(bool isSuccess, const std::string &result); /** Info logger call helper */ inline core::log::details::Info info(); /** Warning logger call helper */ inline core::log::details::Warning warning(); // Tuning bool _bTuningModeIsOn{false}; // Value Space bool _bValueSpaceIsRaw{false}; // Output Raw Format bool _bOutputRawFormatIsHex{false}; // Automatic synchronization to HW during Tuning session bool _bAutoSyncOn{true}; // Current Parameter Settings CParameterBlackboard *_pMainParameterBlackboard; // Dynamic object creation CElementLibrarySet *_pElementLibrarySet; // XML parsing, object creation handling std::string _xmlConfigurationUri; std::string _schemaUri; // Place where schemas stand // Subsystem plugin location const CSubsystemPlugins *_pSubsystemPlugins{nullptr}; // Remote Processor Server IRemoteProcessorServerInterface *_pRemoteProcessorServer{nullptr}; // Parser description array static const SRemoteCommandParserItem gastRemoteCommandParserItems[]; // Maximum command usage length size_t _maxCommandUsageLength{0}; // Blackboard access mutex std::mutex _blackboardMutex; /** Application main logger based on the one provided by the client */ mutable core::log::Logger _logger; /** 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{false}; /** If set to true, missing subsystem will abort parameterMgr start. * If set to false, missing subsystem will fallback on virtual subsystem. */ bool _bFailOnMissingSubsystem{true}; /** 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{true}; /** * 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{false}; };