upstream/parameter/DomainConfiguration.h

/*
 * 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 "AreaConfiguration.h"
#include "XmlDomainImportContext.h"
#include "XmlDomainExportContext.h"
#include "Element.h"
#include "Results.h"
#include <list>
#include <string>
#include <memory>

class CConfigurableElement;
class CParameterBlackboard;
class CConfigurationAccessContext;
class CCompoundRule;
class CSyncerSet;
class CSelectionCriteriaDefinition;

class CDomainConfiguration : public CElement
{
    enum ChildElementType
    {
        ECompoundRule
    };

public:
    CDomainConfiguration(const std::string &strName);

    // Configurable Elements association
    void addConfigurableElement(const CConfigurableElement *configurableElement,
                                const CSyncerSet *syncerSet);
    void removeConfigurableElement(const CConfigurableElement *pConfigurableElement);

    /**
     * Sequence management: Prepend provided elements into internal list in the same order than
     * they appear in the sequence of element path.
     * @param[in] newElementSequence sequence of path of new element
     * @param[out] error human readable error
     * @return true if the new sequence has been taken into account, false otherwise and error is
     * set accordingly.
     */
    bool setElementSequence(const std::vector<std::string> &newElementSequence, std::string &error);
    void getElementSequence(std::string &strResult) const;

    // Application rule
    bool setApplicationRule(const std::string &strApplicationRule,
                            const CSelectionCriteriaDefinition *pSelectionCriteriaDefinition,
                            std::string &strError);
    void clearApplicationRule();
    std::string getApplicationRule() const;

    // Get Blackboard for an element of the domain
    CParameterBlackboard *getBlackboard(const CConfigurableElement *pConfigurableElement) const;

    // Save data from current
    void save(const CParameterBlackboard *pMainBlackboard);

    /** Restore the configuration
     *
     * @param[in] pMainBlackboard the application main blackboard
     * @param[in] bSync indicates if a synchronisation has to be done
     * @param[out] errors, errors encountered during restoration
     * @return true if success false otherwise
     */
    bool restore(CParameterBlackboard *pMainBlackboard, bool bSync,
                 core::Results *errors = nullptr) const;

    // Ensure validity for configurable element area configuration
    void validate(const CConfigurableElement *pConfigurableElement,
                  const CParameterBlackboard *pMainBlackboard);
    // Ensure validity of all area configurations
    void validate(const CParameterBlackboard *pMainBlackboard);
    // Return configuration validity for given configurable element
    bool isValid(const CConfigurableElement *pConfigurableElement) const;
    // Ensure validity of configurable element's area configuration by copying in from a valid one
    void validateAgainst(const CDomainConfiguration *pValidDomainConfiguration,
                         const CConfigurableElement *pConfigurableElement);
    // Ensure validity of all configurable element's area configuration by copying in from a valid
    // ones
    void validateAgainst(const CDomainConfiguration *validDomainConfiguration);
    // Applicability checking
    bool isApplicable() const;
    // Merge existing configurations to given configurable element ones
    void merge(CConfigurableElement *pToConfigurableElement,
               CConfigurableElement *pFromConfigurableElement);
    // Domain splitting
    void split(CConfigurableElement *pFromConfigurableElement);

    // XML configuration settings parsing/composing
    bool parseSettings(CXmlElement &xmlConfigurationSettingsElement,
                       CXmlDomainImportContext &context);
    void composeSettings(CXmlElement &xmlConfigurationSettingsElement,
                         CXmlDomainExportContext &context) const;

    // Class kind
    std::string getKind() const override;

private:
    using AreaConfiguration = std::unique_ptr<CAreaConfiguration>;
    using AreaConfigurations = std::list<AreaConfiguration>;

    // Returns true if children dynamic creation is to be dealt with (here, will allow child
    // deletion upon clean)
    bool childrenAreDynamic() const override;
    // XML configuration settings serializing
    bool importOneConfigurableElementSettings(CAreaConfiguration *areaConfiguration,
                                              CXmlElement &xmlConfigurableElementSettingsElement,
                                              CXmlDomainImportContext &context);
    bool exportOneConfigurableElementSettings(CAreaConfiguration *areaConfiguration,
                                              CXmlElement &xmlConfigurableElementSettingsElement,
                                              CXmlDomainExportContext &context) const;
    // AreaConfiguration retrieval from configurable element
    const AreaConfiguration &getAreaConfiguration(
        const CConfigurableElement *pConfigurableElement) const;

    /**
     * Returns the AreaConfiguration iterator associated to the Element refered by its path
     * @param[in] configurableElementPath to check if found in current list of areaconfigurations
     * @return iterator on the configuration associated to the Element with the given path,
     *                  last if not found
     */
    AreaConfigurations::iterator findAreaConfigurationByPath(
        const std::string &configurableElementPath);

    // Rule
    const CCompoundRule *getRule() const;
    CCompoundRule *getRule();
    void setRule(CCompoundRule *pRule);

    AreaConfigurations mAreaConfigurationList;
};