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);
+}