/* * Copyright (c) 2011-2015, 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 "XmlSerializingContext.h" #include "XmlDomainImportContext.h" #include "XmlDomainExportContext.h" #include "SyncerSet.h" #include "Results.h" #include #include #include #include class CConfigurableElement; class CDomainConfiguration; class CParameterBlackboard; class CSelectionCriteriaDefinition; class CConfigurableDomain : public CElement { typedef std::list::const_iterator ConfigurableElementListIterator; typedef std::map::const_iterator ConfigurableElementToSyncerSetMapIterator; public: CConfigurableDomain() = default; CConfigurableDomain(const std::string &strName); ~CConfigurableDomain() override; // Sequence awareness void setSequenceAwareness(bool bSequenceAware); bool getSequenceAwareness() const; // Configuration Management bool createConfiguration(const std::string &strName, const CParameterBlackboard *pMainBlackboard, std::string &strError); bool deleteConfiguration(const std::string &strName, std::string &strError); bool renameConfiguration(const std::string &strName, const std::string &strNewName, std::string &strError); /** Restore a configuration * * @param[in] configurationName the configuration name * @param[in] mainBlackboard the application main blackboard * @param[in] autoSync boolean which indicates if auto sync mechanism is on * @param[out] errors, errors encountered during restoration * @return true if success false otherwise */ bool restoreConfiguration(const std::string &configurationName, CParameterBlackboard *mainBlackboard, bool autoSync, core::Results &errors) const; bool saveConfiguration(const std::string &strName, const CParameterBlackboard *pMainBlackboard, std::string &strError); bool setElementSequence(const std::string &strConfiguration, const std::vector &astrNewElementSequence, std::string &strError); bool getElementSequence(const std::string &strConfiguration, std::string &strResult) const; bool setApplicationRule(const std::string &strConfiguration, const std::string &strApplicationRule, const CSelectionCriteriaDefinition *pSelectionCriteriaDefinition, std::string &strError); bool clearApplicationRule(const std::string &strConfiguration, std::string &strError); bool getApplicationRule(const std::string &strConfiguration, std::string &strResult) const; // Last applied configuration name std::string getLastAppliedConfigurationName() const; // Pending configuration name std::string getPendingConfigurationName() const; // Associated Configurable elements void gatherConfigurableElements( std::set &configurableElementSet) const; void listAssociatedToElements(std::string &strResult) const; /** Add a configurable element to the domain * * @param[in] pConfigurableElement pointer to the element to add * @param[in] pMainBlackboard pointer to the application main blackboard * @param[out] infos useful information we can provide to client * @return true if succeed false otherwise */ bool addConfigurableElement(CConfigurableElement *pConfigurableElement, const CParameterBlackboard *pMainBlackboard, core::Results &infos); bool removeConfigurableElement(CConfigurableElement *pConfigurableElement, std::string &strError); // Blackboard Configuration and Base Offset retrieval CParameterBlackboard *findConfigurationBlackboard( const std::string &strConfiguration, const CConfigurableElement *pConfigurableElement, size_t &baseOffset, bool &bIsLastApplied, std::string &strError) const; /** Split the domain in two. * Remove an element of a domain and create a new domain which owns the element. * * @param[in] pConfigurableElement pointer to the element to remove * @param[out] infos useful information we can provide to client * @return true if succeed false otherwise */ bool split(CConfigurableElement *pConfigurableElement, core::Results &infos); // Ensure validity on whole domain from main blackboard void validate(const CParameterBlackboard *pMainBlackboard); /** Apply the configuration if required * * @param[in] pParameterBlackboard the blackboard to synchronize * @param[in] pSyncerSet pointer to the set containing application syncers * @param[in] bForced boolean used to force configuration application * @param[out] info string containing useful information we can provide to client */ void apply(CParameterBlackboard *pParameterBlackboard, CSyncerSet *pSyncerSet, bool bForced, std::string &info) const; // Return applicable configuration validity for given configurable element bool isApplicableConfigurationValid(const CConfigurableElement *pConfigurableElement) const; // From IXmlSink bool fromXml(const CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) override; // From IXmlSource void toXml(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const override; void childrenToXml(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const override; // Class kind std::string getKind() const override; protected: // Content dumping std::string logValue(utility::ErrorContext &errorContext) const override; private: // Get pending configuration const CDomainConfiguration *getPendingConfiguration() const; // Search for an applicable configuration const CDomainConfiguration *findApplicableDomainConfiguration() const; // Returns true if children dynamic creation is to be dealt with (here, will allow child // deletion upon clean) bool childrenAreDynamic() const override; // Ensure validity on areas related to configurable element void validateAreas(const CConfigurableElement *pConfigurableElement, const CParameterBlackboard *pMainBlackboard); // Attempt validation for all configurable element's areas, relying on already existing valid // configuration inside domain void autoValidateAll(); // Attempt validation for one configurable element's areas, relying on already existing valid // configuration inside domain void autoValidateAreas(const CConfigurableElement *pConfigurableElement); // Attempt configuration validation for all configurable elements' areas, relying on already // existing valid configuration inside domain bool autoValidateConfiguration(CDomainConfiguration *pDomainConfiguration); // Search for a valid configuration for given configurable element const CDomainConfiguration *findValidDomainConfiguration( const CConfigurableElement *pConfigurableElement) const; // In case configurable element was removed void computeSyncSet(); // Check configurable element already attached bool containsConfigurableElement( const CConfigurableElement *pConfigurableCandidateElement) const; /** Merge any descended configurable element to this one * * @param[in] newElement pointer to element which has potential descendants which can be merged * @param[out] infos useful information we can provide to client */ void mergeAlreadyAssociatedDescendantConfigurableElements(CConfigurableElement *newElement, core::Results &infos); void mergeConfigurations(CConfigurableElement *pToConfigurableElement, CConfigurableElement *pFromConfigurableElement); /** Actually realize the association between the domain and a configurable element * * @param[in] pConfigurableElement pointer to the element to add * @param[out] infos useful information we can provide to client * @param[in] (optional) pMainBlackboard, pointer to the application main blackboard * Default value is NULL, when provided, blackboard area concerning the configurable * element are validated. */ void doAddConfigurableElement(CConfigurableElement *pConfigurableElement, core::Results &infos, const CParameterBlackboard *pMainBlackboard = nullptr); void doRemoveConfigurableElement(CConfigurableElement *pConfigurableElement, bool bRecomputeSyncSet); // XML parsing /** * Deserialize domain configurations from an Xml document and add them to * the domain. * * @param[in] xmlElement the XML element to be parsed * @param[in] serializingContext context for the deserialization * * @return false if an error occurs, true otherwise. */ bool parseDomainConfigurations(const CXmlElement &xmlElement, CXmlDomainImportContext &serializingContext); /** * Deserialize domain elements from an Xml document and add them to * the domain. * * @param[in] xmlElement the XML element to be parsed * @param[in] serializingContext context for the deserialization * * @return false if an error occurs, true otherwise. */ bool parseConfigurableElements(const CXmlElement &xmlElement, CXmlDomainImportContext &serializingContext); /** * Deserialize settings from an Xml document and add them to * the domain. * * @param[in] xmlElement the XML element to be parsed * @param[in] xmlDomainImportContext context for the deserialization * * @return false if an error occurs, true otherwise. */ bool parseSettings(const CXmlElement &xmlElement, CXmlDomainImportContext &serializingContext); // XML composing void composeDomainConfigurations(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const; void composeConfigurableElements(CXmlElement &xmlElement) const; void composeSettings(CXmlElement &xmlElement, CXmlDomainExportContext &context) const; // Syncer set retrieval from configurable element CSyncerSet *getSyncerSet(const CConfigurableElement *pConfigurableElement) const; // Configuration retrieval CDomainConfiguration *findConfiguration(const std::string &strConfiguration, std::string &strError); const CDomainConfiguration *findConfiguration(const std::string &strConfiguration, std::string &strError) const; // Configurable elements std::list _configurableElementList; // Associated syncer sets std::map _configurableElementToSyncerSetMap; // Sequence awareness bool _bSequenceAware{false}; // Syncer set used to ensure propoer synchronization of restored configurable elements CSyncerSet _syncerSet; // Last applied configuration mutable const CDomainConfiguration *_pLastAppliedConfiguration{nullptr}; };