text: /*
   * Copyright (c) 2011-2014, 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 "ParameterMgrPlatformConnector.h"
  #include "ParameterMgr.h"
  #include "ParameterMgrLogger.h"
  #include <assert.h>
  
  using std::string;
  
  // Construction
  CParameterMgrPlatformConnector::CParameterMgrPlatformConnector(
          const string& strConfigurationFilePath) :
      _pParameterMgr(new CParameterMgr(strConfigurationFilePath)), _bStarted(false), _pLogger(NULL)
  {
      // Logging
      _pParameterMgrLogger = new CParameterMgrLogger<CParameterMgrPlatformConnector>(*this);
      _pParameterMgr->setLogger(_pParameterMgrLogger);
  }
  
  CParameterMgrPlatformConnector::~CParameterMgrPlatformConnector()
  {
      delete _pParameterMgr;
      delete _pParameterMgrLogger;
  }
  
  // Selection Criteria interface. Beware returned objects are lent, clients shall not delete them!
  ISelectionCriterionTypeInterface* CParameterMgrPlatformConnector::createSelectionCriterionType(bool bIsInclusive)
  {
      assert(!_bStarted);
  
      return _pParameterMgr->createSelectionCriterionType(bIsInclusive);
  }
  
  ISelectionCriterionInterface* CParameterMgrPlatformConnector::createSelectionCriterion(const string& strName, const ISelectionCriterionTypeInterface* pSelectionCriterionType)
  {
      assert(!_bStarted);
  
      return _pParameterMgr->createSelectionCriterion(strName, static_cast<const CSelectionCriterionType*>(pSelectionCriterionType));
  }
  
  // Selection criterion retrieval
  ISelectionCriterionInterface* CParameterMgrPlatformConnector::getSelectionCriterion(const string& strName) const
  {
      return _pParameterMgr->getSelectionCriterion(strName);
  }
  
  // Configuration application
  void CParameterMgrPlatformConnector::applyConfigurations()
  {
      assert(_bStarted);
  
      _pParameterMgr->applyConfigurations();
  }
  
  // Dynamic parameter handling
  CParameterHandle* CParameterMgrPlatformConnector::createParameterHandle(const string& strPath, string& strError) const
  {
      assert(_bStarted);
  
      return _pParameterMgr->createParameterHandle(strPath, strError);
  }
  
  // Logging
  void CParameterMgrPlatformConnector::setLogger(CParameterMgrPlatformConnector::ILogger* pLogger)
  {
      _pLogger = pLogger;
  }
  
  bool CParameterMgrPlatformConnector::getForceNoRemoteInterface() const
  {
      return _pParameterMgr->getForceNoRemoteInterface();
  }
  
  void CParameterMgrPlatformConnector::setForceNoRemoteInterface(bool bForceNoRemoteInterface)
  {
      _pParameterMgr->setForceNoRemoteInterface(bForceNoRemoteInterface);
  }
  
  bool CParameterMgrPlatformConnector::setFailureOnMissingSubsystem(bool bFail, string &strError)
  {
      if (_bStarted) {
  
          strError = "Can not set missing subsystem policy while running";
          return false;
      }
  
      _pParameterMgr->setFailureOnMissingSubsystem(bFail);
      return true;
  }
  
  bool CParameterMgrPlatformConnector::getFailureOnMissingSubsystem()
  {
      return _pParameterMgr->getFailureOnMissingSubsystem();
  }
  
  bool CParameterMgrPlatformConnector::setFailureOnFailedSettingsLoad(
          bool bFail, std::string& strError)
  {
      if (_bStarted) {
  
          strError = "Can not set failure on failed settings load policy while running";
          return false;
      }
  
      _pParameterMgr->setFailureOnFailedSettingsLoad(bFail);
      return true;
  }
  
  bool CParameterMgrPlatformConnector::getFailureOnFailedSettingsLoad()
  {
      return _pParameterMgr->getFailureOnFailedSettingsLoad();
  }
  
  const string& CParameterMgrPlatformConnector::getSchemaFolderLocation() const
  {
      return _pParameterMgr->getSchemaFolderLocation();
  }
  
  void CParameterMgrPlatformConnector::setSchemaFolderLocation(const string& strSchemaFolderLocation)
  {
      _pParameterMgr->setSchemaFolderLocation(strSchemaFolderLocation);
  }
  
  bool CParameterMgrPlatformConnector::setValidateSchemasOnStart(
      bool bValidate, std::string& strError)
  {
      if (_bStarted) {
  
          strError = "Can not enable xml validation after the start of the parameter-framework";
          return false;
      }
  
      _pParameterMgr->setValidateSchemasOnStart(bValidate);
      return true;
  }
  
  bool CParameterMgrPlatformConnector::getValidateSchemasOnStart()
  {
      return _pParameterMgr->getValidateSchemasOnStart();
  }
  
  // Start
  bool CParameterMgrPlatformConnector::start(string& strError)
  {
      // Create data structure
      if (!_pParameterMgr->load(strError)) {
  
          return false;
      }
  
      _bStarted = true;
  
      return true;
  }
  
  // Started state
  bool CParameterMgrPlatformConnector::isStarted() const
  {
      return _bStarted;
  }
  
  // Private logging
  void CParameterMgrPlatformConnector::doLog(bool bIsWarning, const string& strLog)
  {
      if (_pLogger) {
  
          _pLogger->log(bIsWarning, strLog);
      }
  }
  