You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
291 lines
13 KiB
291 lines
13 KiB
/*
|
|
* 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 <list>
|
|
#include <set>
|
|
#include <map>
|
|
#include <string>
|
|
|
|
class CConfigurableElement;
|
|
class CDomainConfiguration;
|
|
class CParameterBlackboard;
|
|
class CSelectionCriteriaDefinition;
|
|
|
|
class CConfigurableDomain : public CElement
|
|
{
|
|
typedef std::list<CConfigurableElement *>::const_iterator ConfigurableElementListIterator;
|
|
typedef std::map<const CConfigurableElement *, CSyncerSet *>::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<std::string> &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<const CConfigurableElement *> &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<CConfigurableElement *> _configurableElementList;
|
|
|
|
// Associated syncer sets
|
|
std::map<const CConfigurableElement *, CSyncerSet *> _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};
|
|
};
|