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 <david.wagner@intel.com>

1 files changed, 350 insertions, 0 deletions

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 <list>
+
+using std::string;
+
+CParameterMgrFullConnector::CParameterMgrFullConnector(const string& strConfigurationFilePath) :
+    _pParameterMgr(new CParameterMgr(strConfigurationFilePath)), _pLogger(NULL)
+{
+    _pParameterMgrLogger = new CParameterMgrLogger<CParameterMgrFullConnector>(*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<const CSelectionCriterionType*>(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<string>& 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<string>& 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);
+}