From 36f40a0b7eee0a6d8b6ca54fdfb1b9043845a555 Mon Sep 17 00:00:00 2001 From: David Wagner Date: Tue, 6 Jan 2015 18:33:36 +0100 Subject: New ParamegerMgr "Full" connector This is a new connector that implements (almost) all of the parameter-framework capabilities, in contrast to CParameterMgrPlatformConnector which only implements criteria creation, modification, and application and dynamic parameter handling capabilities. It will allow user to programatically do whatever the PFW can do, e.g. create domains and configurations. Change-Id: Ide118aaaae4f84fa7280d2cae470de0c024c0f00 Signed-off-by: David Wagner --- parameter/ParameterMgrFullConnector.cpp | 350 ++++++++++++++++++++++++++++++++ 1 file changed, 350 insertions(+) create mode 100644 parameter/ParameterMgrFullConnector.cpp (limited to 'parameter/ParameterMgrFullConnector.cpp') diff --git a/parameter/ParameterMgrFullConnector.cpp b/parameter/ParameterMgrFullConnector.cpp new file mode 100644 index 0000000..92a8e04 --- /dev/null +++ b/parameter/ParameterMgrFullConnector.cpp @@ -0,0 +1,350 @@ +/* + * Copyright (c) 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. + */ +#include "ParameterMgrFullConnector.h" +#include "ParameterMgr.h" +#include "ParameterMgrLogger.h" + +#include + +using std::string; + +CParameterMgrFullConnector::CParameterMgrFullConnector(const string& strConfigurationFilePath) : + _pParameterMgr(new CParameterMgr(strConfigurationFilePath)), _pLogger(NULL) +{ + _pParameterMgrLogger = new CParameterMgrLogger(*this); + _pParameterMgr->setLogger(_pParameterMgrLogger); +} + +CParameterMgrFullConnector::~CParameterMgrFullConnector() +{ + delete _pParameterMgr; + delete _pParameterMgrLogger; +} + + +bool CParameterMgrFullConnector::start(string& strError) +{ + // Create data structure & Init flow + return _pParameterMgr->load(strError) && _pParameterMgr->init(strError); +} + +void CParameterMgrFullConnector::setLogger(CParameterMgrFullConnector::ILogger* pLogger) +{ + _pLogger = pLogger; +} + +// Private logging +void CParameterMgrFullConnector::doLog(bool bIsWarning, const string& strLog) +{ + if (_pLogger) { + + _pLogger->log(bIsWarning, strLog); + } +} + +CParameterHandle* CParameterMgrFullConnector::createParameterHandle(const string& strPath, + string& strError) +{ + return _pParameterMgr->createParameterHandle(strPath, strError); +} + +ISelectionCriterionTypeInterface* CParameterMgrFullConnector::createSelectionCriterionType( + bool bIsInclusive) +{ + return _pParameterMgr->createSelectionCriterionType(bIsInclusive); +} + +ISelectionCriterionInterface* CParameterMgrFullConnector::createSelectionCriterion( + const string& strName, + const ISelectionCriterionTypeInterface* pSelectionCriterionType) +{ + return _pParameterMgr->createSelectionCriterion(strName, + static_cast(pSelectionCriterionType)); +} + +ISelectionCriterionInterface* CParameterMgrFullConnector::getSelectionCriterion( + const string& strName) +{ + return _pParameterMgr->getSelectionCriterion(strName); +} + +void CParameterMgrFullConnector::applyConfigurations() +{ + return _pParameterMgr->applyConfigurations(); +} + +void CParameterMgrFullConnector::setFailureOnMissingSubsystem(bool bFail) +{ + _pParameterMgr->setFailureOnMissingSubsystem(bFail); +} + +bool CParameterMgrFullConnector::getFailureOnMissingSubsystem() const +{ + return _pParameterMgr->getFailureOnMissingSubsystem(); +} + +void CParameterMgrFullConnector::setFailureOnFailedSettingsLoad(bool bFail) +{ + _pParameterMgr->setFailureOnFailedSettingsLoad(bFail); +} + +bool CParameterMgrFullConnector::getFailureOnFailedSettingsLoad() +{ + return _pParameterMgr->getFailureOnFailedSettingsLoad(); +} + +void CParameterMgrFullConnector::setValidateSchemasOnStart(bool bValidate) +{ + _pParameterMgr->setValidateSchemasOnStart(bValidate); +} + +bool CParameterMgrFullConnector::getValidateSchemasOnStart() const +{ + return _pParameterMgr->getValidateSchemasOnStart(); +} + +bool CParameterMgrFullConnector::setTuningMode(bool bOn, string& strError) +{ + return _pParameterMgr->setTuningMode(bOn, strError); +} + +bool CParameterMgrFullConnector::isTuningModeOn() const +{ + return _pParameterMgr->tuningModeOn(); +} + +void CParameterMgrFullConnector::setValueSpace(bool bIsRaw) +{ + return _pParameterMgr->setValueSpace(bIsRaw); +} + +bool CParameterMgrFullConnector::isValueSpaceRaw() const +{ + return _pParameterMgr->valueSpaceIsRaw(); +} + +void CParameterMgrFullConnector::setOutputRawFormat(bool bIsHex) +{ + return _pParameterMgr->setOutputRawFormat(bIsHex); +} + +bool CParameterMgrFullConnector::isOutputRawFormatHex() const +{ + return _pParameterMgr->outputRawFormatIsHex(); +} + +bool CParameterMgrFullConnector::setAutoSync(bool bAutoSyncOn, string& strError) +{ + return _pParameterMgr->setAutoSync(bAutoSyncOn, strError); +} + +bool CParameterMgrFullConnector::isAutoSyncOn() const +{ + return _pParameterMgr->autoSyncOn(); +} + +bool CParameterMgrFullConnector::sync(string& strError) +{ + return _pParameterMgr->sync(strError); +} + +bool CParameterMgrFullConnector::accessParameterValue(const string& strPath, string& strValue, + bool bSet, string& strError) +{ + return _pParameterMgr->accessParameterValue(strPath, strValue, bSet, strError); +} + +bool CParameterMgrFullConnector::accessConfigurationValue(const string &strDomain, + const string &strConfiguration, + const string& strPath, string& strValue, + bool bSet, string& strError) +{ + return _pParameterMgr->accessConfigurationValue(strDomain, strConfiguration, strPath, strValue, + bSet, strError); +} + +bool CParameterMgrFullConnector::getParameterMapping(const string& strPath, string& strValue) const +{ + return _pParameterMgr->getParameterMapping(strPath, strValue); +} + +bool CParameterMgrFullConnector::createDomain(const string& strName, string& strError) +{ + return _pParameterMgr->createDomain(strName, strError); +} + +bool CParameterMgrFullConnector::deleteDomain(const string& strName, string& strError) +{ + return _pParameterMgr->deleteDomain(strName, strError); +} + +bool CParameterMgrFullConnector::renameDomain(const string& strName, const string& strNewName, + string& strError) +{ + return _pParameterMgr->renameDomain(strName, strNewName, strError); +} + +bool CParameterMgrFullConnector::deleteAllDomains(string& strError) +{ + return _pParameterMgr->deleteAllDomains(strError); +} + +bool CParameterMgrFullConnector::createConfiguration(const string& strDomain, + const string& strConfiguration, + string& strError) +{ + return _pParameterMgr->createConfiguration(strDomain, strConfiguration, strError); +} + +bool CParameterMgrFullConnector::deleteConfiguration(const string& strDomain, + const string& strConfiguration, + string& strError) +{ + return _pParameterMgr->deleteConfiguration(strDomain, strConfiguration, strError); +} + +bool CParameterMgrFullConnector::renameConfiguration(const string& strDomain, + const string& strConfiguration, + const string& strNewConfiguration, + string& strError) +{ + return _pParameterMgr->renameConfiguration(strDomain, strConfiguration, strNewConfiguration, + strError); +} + +bool CParameterMgrFullConnector::saveConfiguration(const string& strDomain, + const string& strConfiguration, string& strError) +{ + return _pParameterMgr->saveConfiguration(strDomain, strConfiguration, strError); +} + +bool CParameterMgrFullConnector::restoreConfiguration(const string& strDomain, + const string& strConfiguration, + std::list& lstrError) +{ + return _pParameterMgr->restoreConfiguration(strDomain, strConfiguration, lstrError); +} + +bool CParameterMgrFullConnector::setSequenceAwareness(const string& strName, bool bSequenceAware, + string& strResult) +{ + return _pParameterMgr->setSequenceAwareness(strName, bSequenceAware, strResult); +} + +bool CParameterMgrFullConnector::getSequenceAwareness(const string& strName, bool& bSequenceAware, + string& strResult) +{ + return _pParameterMgr->getSequenceAwareness(strName, bSequenceAware, strResult); +} + +bool CParameterMgrFullConnector::addConfigurableElementToDomain(const string& strDomain, + const string& strConfigurableElementPath, string& strError) +{ + return _pParameterMgr->addConfigurableElementToDomain(strDomain, strConfigurableElementPath, + strError); +} + +bool CParameterMgrFullConnector::removeConfigurableElementFromDomain(const string& strDomain, + const string& strConfigurableElementPath, string& strError) +{ + return _pParameterMgr->removeConfigurableElementFromDomain(strDomain, + strConfigurableElementPath, strError); +} + +bool CParameterMgrFullConnector::split(const string& strDomain, + const string& strConfigurableElementPath, string& strError) +{ + return _pParameterMgr->split(strDomain, strConfigurableElementPath, strError); +} + +bool CParameterMgrFullConnector::setElementSequence(const string& strDomain, + const string& strConfiguration, + const std::vector& astrNewElementSequence, + string& strError) +{ + return _pParameterMgr->setElementSequence(strDomain, strConfiguration, astrNewElementSequence, + strError); +} + +bool CParameterMgrFullConnector::setApplicationRule(const string& strDomain, + const string& strConfiguration, + const string& strApplicationRule, + string& strError) +{ + return _pParameterMgr->setApplicationRule(strDomain, strConfiguration, strApplicationRule, + strError); +} + + +bool CParameterMgrFullConnector::getApplicationRule(const string& strDomain, + const string& strConfiguration, + string& strResult) +{ + return _pParameterMgr->getApplicationRule(strDomain, strConfiguration, strResult); +} +bool CParameterMgrFullConnector::clearApplicationRule(const string& strDomain, + const string& strConfiguration, + string& strError) +{ + return _pParameterMgr->clearApplicationRule(strDomain, strConfiguration, strError); +} + + +bool CParameterMgrFullConnector::importDomainsXml(const string& strXmlSource, bool bWithSettings, + bool bFromFile, string& strError) +{ + return _pParameterMgr->importDomainsXml(strXmlSource, bWithSettings, bFromFile, strError); +} + +bool CParameterMgrFullConnector::exportDomainsXml(string& strXmlDest, bool bWithSettings, + bool bToFile, string& strError) const +{ + return _pParameterMgr->exportDomainsXml(strXmlDest, bWithSettings, bToFile, strError); +} + +bool CParameterMgrFullConnector::importSingleDomainXml(const string& strXmlSource, bool bOverwrite, + string& strError) +{ + return _pParameterMgr->importSingleDomainXml(strXmlSource, bOverwrite, strError); +} + +bool CParameterMgrFullConnector::exportSingleDomainXml(string& strXmlDest, + const string& strDomainName, + bool bWithSettings, bool bToFile, + string& strError) const +{ + return _pParameterMgr->exportSingleDomainXml(strXmlDest, strDomainName, bWithSettings, bToFile, + strError); +} + +bool CParameterMgrFullConnector::getSystemClassXMLString(string& strResult) +{ + return _pParameterMgr->getSystemClassXMLString(strResult); +} -- cgit v1.1