path: root/nsframework/notification_persistent_service/server/src/ns_npp_persistence_manager.cpp

/*
 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \ingroup  tag_NPPService
/// \brief    This file contains implementation of class CPersistenceManager.
///
///
////////////////////////////////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <dirent.h>
#include <sys/types.h>
#include <native_service/ns_np_service.h>
#include <native_service/ns_np_service_if.h>
#include <native_service/ns_util_directory.h>
#include <native_service/ns_np_service_protocol.h>
#include <native_service/frameworkunified_sm_framework_dispatch.h>
#include <string>
#include <native_service/ns_np_service_nor_persistence_internal.h>
#include "ns_npp.h"
#include "ns_npp_types.h"
#include "ns_npp_notificationpersistentservicelog.h"
#include "ns_npp_copy_worker.h"
#include "ns_npp_persistence.h"
#include "ns_npp_persist_file.h"
#include "ns_npp_fs_directory.h"
#include "ns_npp_persist_folder.h"
#include "ns_npp_persistent_data.h"
#include "ns_npp_binary_accesser.h"
#include "ns_npp_persistence_manager.h"
#include "ns_npp_nor_persistence_worker_thread.h"
#include "ns_npp_state_nor_persistence_notification.h"

extern const CHAR AppName[];  // NOLINT (readability/naming)

// Initialisation of static class member for disabling persistence
BOOL CPersistenceManager::m_bPersistenceDisabled = FALSE;

////////////////////////////////////////////////////////////////////////////////////////////////////
/// CPersistenceManager
/// Constructor of CPersistenceManager class
////////////////////////////////////////////////////////////////////////////////////////////////////
CPersistenceManager::CPersistenceManager() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  m_cUserNotificationTag = USERNOTIFICATIONFILE;

  m_poDataAccesser = NULL;

  m_cNotificationPersistFilepath = CPersistence::GetStoragePath();    // LCOV_EXCL_BR_LINE 11: unexpected branch

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Storage path for persistence=%s", m_cNotificationPersistFilepath.c_str());   // LCOV_EXCL_BR_LINE 11: unexpected branch  // NOLINT[whitespace/line_length]

  m_cNotificationPersistFilepath += AppName;
  m_cNotificationPersistFilepath += "/";

  m_hNSImmediatePersistenceThread = NULL;
  m_bAllFilePersisted = FALSE;
  m_bImmediatedDataPersisted = FALSE;

  if (eFrameworkunifiedStatusOK != Init()) {  // LCOV_EXCL_BR_LINE 6: Init() must be return eFrameworkunifiedStatusOK
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to initialize Persistent Manager.");  // LCOV_EXCL_LINE 6: Init() must be return eFrameworkunifiedStatusOK  // NOLINT[whitespace/line_length]
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// CPersistenceManager
/// Destructor of CPersistenceManager class
////////////////////////////////////////////////////////////////////////////////////////////////////
CPersistenceManager::~CPersistenceManager() {  // LCOV_EXCL_START 14: Resident process, global instance not released
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (NULL != m_poDataAccesser) {
    delete m_poDataAccesser;
  }

  Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin();
  // Remove memory allocated for persistence objects
  for (; l_itPersist_Type != m_mPersist_Type.end(); ++l_itPersist_Type) {
    if (NULL != (*l_itPersist_Type).second) {
      delete(*l_itPersist_Type).second;
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}
// LCOV_EXCL_STOP

EFrameworkunifiedStatus CPersistenceManager::Init() {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  m_mPersist_Type[ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE] = new(std::nothrow) CFilePersistence();    // LCOV_EXCL_BR_LINE 11:unexpected branch

  m_mPersist_Type[ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER] = new(std::nothrow) CFolderPersistence();    // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT[whitespace/line_length]

  m_poDataAccesser = new(std::nothrow) CBinaryAccesser();  // Save data in binary format.   // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT[whitespace/line_length]

  // check if all object creation is successful
  if (NULL != m_poDataAccesser) {   // LCOV_EXCL_BR_LINE 5:m_poDataAccesser can`t be NULL
    Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin();

    // check if all object creation is successful
    for (; l_itPersist_Type != m_mPersist_Type.end();
         ++l_itPersist_Type) {
      if (NULL == (*l_itPersist_Type).second) {  // LCOV_EXCL_START 6:(*l_itPersist_Type).second can`t be NULL
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        l_estatus = eFrameworkunifiedStatusFail;
        break;
      }
      // LCOV_EXCL_STOP
    }
  } else {
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_estatus = eFrameworkunifiedStatusFail;  // LCOV_EXCL_LINE 5: m_poDataAccesser can`t be NULL
  }

  if (eFrameworkunifiedStatusOK != l_estatus) {   // LCOV_EXCL_START 6: l_estatus must be eFrameworkunifiedStatusOK
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    if (NULL != m_poDataAccesser) {
      delete m_poDataAccesser;
    }

    Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin();
    // check if all object creation is successful
    for (; l_itPersist_Type != m_mPersist_Type.end(); ++l_itPersist_Type) {
      if (NULL != (*l_itPersist_Type).second) {
        delete(*l_itPersist_Type).second;
      }
    }
    // LCOV_EXCL_STOP
  }
  std::string f_csourcepath = CPersistence::GetStoragePath();
  if (f_csourcepath.length() > 0) {   // LCOV_EXCL_BR_LINE 6: f_csourcepath.length() is always bigger then 0
    f_csourcepath.append(RELEASETEMP_DIR);    // LCOV_EXCL_BR_LINE 11:unexpected branch
    if (CFSDirectory::DoesDirecotryExist(f_csourcepath)) {
      f_csourcepath.append(RELEASETEMP_FILENAME);
      if (0 != remove(f_csourcepath.c_str())) {
        FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Temporary file not deleted::%s, errno:%d", f_csourcepath.c_str(), errno);
      }
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceRegister
/// Registers a tag for the file/folder. This tag will be used for releasing or loading
/// a file/folder.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceRegister(std::string f_cappname,
                                            std::string f_ctag,
                                            ENotificationpersistentservicePersistType f_epersisttype,
                                            BOOL bisuserpersistence) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail;

  if (f_cappname.empty() || f_ctag.empty()) {  // LCOV_EXCL_BR_LINE 6: double check, f_cappname and f_ctag can't be empty  // NOLINT[whitespace/line_length]
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Appname & tag should not be empty.");  // LCOV_EXCL_LINE 6: f_cappname and f_ctag can't be empty  // NOLINT[whitespace/line_length]
  } else {
    // check boundary conditions
    if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) {  // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
      if (NULL != m_mPersist_Type[f_epersisttype]) {  // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] would not be null  // NOLINT[whitespace/line_length]
        // register tag
        l_estatus = m_mPersist_Type[f_epersisttype]->Register(f_cappname, f_ctag,
                                                              bisuserpersistence);  // f_eRegisterType, f_cUser); // LCOV_EXCL_BR_LINE 11: unexpected branch  // NOLINT[whitespace/line_length]
        // m_mPersist_Type[f_ePersistFileType]->ListAllInMap();
      } else {
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype);   // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] would not be null  // NOLINT[whitespace/line_length]
      }
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype);  // LCOV_EXCL_LINE 6: f_epersisttype is always biger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceRelease
/// Entry for the file/folder is stored in map for persistence.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceRelease(std::string f_cappname,
                                           std::string f_ctag,
                                           std::string f_cmempath,
                                           EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype,
                                           ENotificationpersistentservicePersistType f_epersisttype,
                                           std::string f_cusername) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail;

  if (f_cappname.empty() || f_ctag.empty() || f_cmempath.empty()) {  // LCOV_EXCL_BR_LINE 6: double check, f_cappname, f_cmempath and f_ctag can't be empty  // NOLINT[whitespace/line_length]
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Appname & tag should not be empty.");  // LCOV_EXCL_LINE 6: double check, f_cappname, f_cmempath and f_ctag can't be empty  // NOLINT[whitespace/line_length]
  } else {
    // check boundary conditions
    if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) {  // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
      // release file
      if (NULL != m_mPersist_Type[f_epersisttype]) {  // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] would not be null  // NOLINT[whitespace/line_length]
        l_estatus = m_mPersist_Type[f_epersisttype]->Release(f_cappname,
                                                             f_ctag,
                                                             f_cmempath,
                                                             enotificationpersistentservicereleasetype,
                                                             f_cusername);    // LCOV_EXCL_BR_LINE 11: unexpected branch
      } else {
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype);  // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] would not be null  // NOLINT[whitespace/line_length]
      }
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype);  // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceLoad
/// Load file/folder from persistent memory to the specified location.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceLoad(std::string f_cappname,
                                        std::string f_ctag,
                                        std::string f_cretrievepath,
                                        ENotificationpersistentservicePersistType f_epersisttype,
                                        std::string f_cusername) {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (f_cappname.empty() || f_ctag.empty() || f_cretrievepath.empty()) {  // LCOV_EXCL_BR_LINE 6: double check, f_cretrievepath, f_cappname and f_ctag can't be empty  // NOLINT[whitespace/line_length]
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Appname, tag & retrieve path should not be empty.");  // LCOV_EXCL_LINE 6: double check, f_cretrievepath, f_cappname and f_ctag can't be empty  // NOLINT[whitespace/line_length]
  } else {
    // check boundary conditions
    if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) {  // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
      if (NULL != m_mPersist_Type[f_epersisttype]) {  // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] would not be null  // NOLINT[whitespace/line_length]
        // load file
        l_estatus = m_mPersist_Type[f_epersisttype]->Load(f_cappname, f_ctag, f_cretrievepath, f_cusername);  // LCOV_EXCL_BR_LINE 11: unexpected branch  // NOLINT[whitespace/line_length]
      } else {
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype);   // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] would not be null  // NOLINT[whitespace/line_length]
      }
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype);   // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// AckReceivedFromWorker
/// Send release ack to file/folder persistence object.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::AckReceivedFromWorker(PCSTR f_csource, PCSTR f_ctag, ENotificationpersistentservicePersistType f_epersisttype,
                                                      BOOL f_bcopystatus, ENPS_Loadtype f_eloadtype) {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if ((NULL == f_csource) || (NULL == f_ctag)) {  // LCOV_EXCL_BR_LINE 6: f_csource and f_ctag can't be NULL
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "f_csource or f_ctag is NULL.");  // LCOV_EXCL_LINE 6: f_csource and f_ctag can't be NULL  // NOLINT[whitespace/line_length]
  } else {
    // check boundary conditions
    if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) {   // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
      if (NULL != m_mPersist_Type[f_epersisttype]) {
        // Send release ack to file/folder persistence object.
        l_estatus = m_mPersist_Type[f_epersisttype]->AckReceivedFromWorker(f_csource, f_ctag,
                                                                           f_bcopystatus, f_eloadtype);
      } else {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype);
      }
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype);   // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceSaveNotificationData
/// Save notification data in a persistent file.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceSaveNotificationData(Persistent_Notification_List_Type
                                                        *f_vpersistentnotificationlist) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if ((NULL == m_poDataAccesser) || (NULL == f_vpersistentnotificationlist)) {  // LCOV_EXCL_BR_LINE 6: m_poDataAccesser and f_vpersistentnotificationlist would not be null  // NOLINT[whitespace/line_length]
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "m_poDataAccesser or f_vpersistentnotificationlist is NULL.");   // LCOV_EXCL_LINE 6: m_poDataAccesser and f_vpersistentnotificationlist would not be null  // NOLINT[whitespace/line_length]
  } else {
    EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;
    std::string l_cNotificationFilePath = "";

    l_cNotificationFilePath = m_cNotificationPersistFilepath;
    l_cNotificationFilePath +=  NOTIFICATIONFILE;
    if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->PersistData(l_cNotificationFilePath,
                                                                   f_vpersistentnotificationlist,
                                                                   eFrameworkunifiedPersistedStateVar,
                                                                   eFrameworkunifiedUserData))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d",
             l_cNotificationFilePath.c_str(), l_estatus);
    }

    l_cNotificationFilePath = m_cNotificationPersistFilepath;
    l_cNotificationFilePath +=  FACTORYNOTIFICATIONFILE;
    if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->PersistData(l_cNotificationFilePath,
                                                                   f_vpersistentnotificationlist,
                                                                   eFrameworkunifiedPersistedStateVar,
                                                                   eFrameworkunifiedFactoryData))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d",
             l_cNotificationFilePath.c_str(), l_estatus);
    }

    l_cNotificationFilePath = m_cNotificationPersistFilepath;
    l_cNotificationFilePath +=  FACTORYCUSTOMERNOTIFICATIONFILE;
    if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->PersistData(l_cNotificationFilePath,
                                                                   f_vpersistentnotificationlist,
                                                                   eFrameworkunifiedPersistedStateVar,
                                                                   eFrameworkunifiedFactoryCustomerData))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d",
             l_cNotificationFilePath.c_str(), l_estatus);
    }

    l_cNotificationFilePath = m_cNotificationPersistFilepath;
    l_cNotificationFilePath +=  DEALERNOTIFICATIONFILE;
    if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->PersistData(l_cNotificationFilePath,
                                                                   f_vpersistentnotificationlist,
                                                                   eFrameworkunifiedPersistedStateVar,
                                                                   eFrameworkunifiedDealerData))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d",
             l_cNotificationFilePath.c_str(), l_estatus);
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eFrameworkunifiedStatusOK;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceSaveUserNotificationData
/// Save user notification data in a persistent file.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceSaveUserNotificationData(Persistent_Notification_List_Type
                                                            *f_vpersistentnotificationlist) {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if ((NULL == m_poDataAccesser) || (NULL == f_vpersistentnotificationlist)) {  // LCOV_EXCL_BR_LINE 6: m_poDataAccesser and f_vpersistentnotificationlist would not be null  // NOLINT[whitespace/line_length]
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "m_poDataAccesser or f_vpersistentnotificationlist is NULL.");   // LCOV_EXCL_LINE 6: m_poDataAccesser and f_vpersistentnotificationlist would not be null  // NOLINT[whitespace/line_length]
  } else {
    l_estatus = m_poDataAccesser->PersistData(m_cNotificationUserMemFilepath,
                                              f_vpersistentnotificationlist,
                                              eFrameworkunifiedPersistedStateUserVar);   // LCOV_EXCL_BR_LINE 11: unexpected branch
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceReadNotificationData
/// Get the list of all persistent notifications from a persistent memory and store it in a map.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceReadNotificationData(Persistent_Notification_List_Type
                                                        * &f_vpersistentnotificationlist) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (NULL != m_poDataAccesser) {   // LCOV_EXCL_BR_LINE 6: m_poDataAccesser would not be null
    EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;
    std::string l_cNotificationFilePath = "";

    l_cNotificationFilePath = m_cNotificationPersistFilepath;
    l_cNotificationFilePath += NOTIFICATIONFILE;
    if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->RetrieveData(l_cNotificationFilePath,
                                                                    f_vpersistentnotificationlist,
                                                                    eFrameworkunifiedUserData))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d",
             l_cNotificationFilePath.c_str(), l_estatus);
    }

    l_cNotificationFilePath = m_cNotificationPersistFilepath;
    l_cNotificationFilePath += FACTORYNOTIFICATIONFILE;
    if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->RetrieveData(l_cNotificationFilePath,
                                                                    f_vpersistentnotificationlist,
                                                                    eFrameworkunifiedFactoryData))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d",
             l_cNotificationFilePath.c_str(), l_estatus);
    }

    l_cNotificationFilePath = m_cNotificationPersistFilepath;
    l_cNotificationFilePath += FACTORYCUSTOMERNOTIFICATIONFILE;
    if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->RetrieveData(l_cNotificationFilePath,
                                                                    f_vpersistentnotificationlist,
                                                                    eFrameworkunifiedFactoryCustomerData))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d",
             l_cNotificationFilePath.c_str(), l_estatus);
    }

    l_cNotificationFilePath = m_cNotificationPersistFilepath;
    l_cNotificationFilePath += DEALERNOTIFICATIONFILE;
    if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->RetrieveData(l_cNotificationFilePath,
                                                                    f_vpersistentnotificationlist,
                                                                    eFrameworkunifiedDealerData))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d",
             l_cNotificationFilePath.c_str(), l_estatus);
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eFrameworkunifiedStatusOK;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceReadUserNotificationData
/// Get the list of all user persistent notifications from a persistent memory and store it in a map.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceReadUserNotificationData(Persistent_Notification_List_Type
                                                            * &f_vpersistentnotificationlist) {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (NULL != m_poDataAccesser) {   // LCOV_EXCL_BR_LINE 6: m_poDataAccesser would not be null
    l_estatus = m_poDataAccesser->RetrieveData(m_cNotificationUserMemFilepath,
                                               f_vpersistentnotificationlist,
                                               eFrameworkunifiedUserData);   // LCOV_EXCL_BR_LINE 11:unexpected branch
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// PersistAllReleaseRequests
/// Persist all released files and folder contained in the map in persistent memory.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::PersistAllReleaseRequests(UI_32 f_uinotificationpersistentservicepersistcategoryflag) {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  ENotificationpersistentservicePersistType l_ePersistType = ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST;
  l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1);

  // Persist all i.e files and folders
  while (l_ePersistType < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) {
    if (NULL != m_mPersist_Type[l_ePersistType]) {
      if (eFrameworkunifiedStatusFail == m_mPersist_Type[l_ePersistType]->PersistAllReleaseRequests(f_uinotificationpersistentservicepersistcategoryflag)) {   // LCOV_EXCL_BR_LINE 4: NSFW error case.  // NOLINT[whitespace/line_length]
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        l_estatus = eFrameworkunifiedStatusFail;   // LCOV_EXCL_LINE 4: NSFW error case.
      }
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", l_ePersistType);   // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"  // NOLINT[whitespace/line_length]
    }

    l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}


////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentservicePersistAllUserRequests
/// Persist all user files and folder contained in the map in persistent memory.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentservicePersistAllUserRequests() {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  ENotificationpersistentservicePersistType l_ePersistType = ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST;
  l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1);

  // Persist all i.e files and folders
  while (l_ePersistType < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) {
    if (NULL != m_mPersist_Type[l_ePersistType]) {
      l_estatus = m_mPersist_Type[l_ePersistType]->PersistAllUserRequests();
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", l_ePersistType);
    }

    l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}



////////////////////////////////////////////////////////////////////////////////////////////////
/// SetReadThreadHandle
/// Pass the handle of the read thread to the object of file/folder persistence
////////////////////////////////////////////////////////////////////////////////////////////////
VOID CPersistenceManager::SetReadThreadHandle(HANDLE f_hreadthread) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (f_hreadthread != NULL) {    // LCOV_EXCL_BR_LINE 6: f_hreadthread would not be null
    // Set thread handle for object persistfile objects. i.e. for file/folder
    for (Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin();
         l_itPersist_Type != m_mPersist_Type.end();
         ++l_itPersist_Type) {
      if (NULL != (*l_itPersist_Type).second) {  // LCOV_EXCL_BR_LINE 6: (*l_itPersist_Type).second can't be NULL
        (*l_itPersist_Type).second->SetReadThreadHandle(f_hreadthread);
      }
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// SetWriteThreadHandle
/// Pass the handle of the write thread to the object of file/folder persistence
////////////////////////////////////////////////////////////////////////////////////////////////
VOID CPersistenceManager::SetWriteThreadHandle(HANDLE f_hwritethread) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (NULL != f_hwritethread) {   // LCOV_EXCL_BR_LINE 6: f_hwritethread would not be null
    // Set thread handle for object persist objects. i.e. for file/folder
    for (Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin();
         l_itPersist_Type != m_mPersist_Type.end();
         ++l_itPersist_Type) {
      if (NULL != (*l_itPersist_Type).second) {  // LCOV_EXCL_BR_LINE 6: (*l_itPersist_Type).second can't be NULL
        (*l_itPersist_Type).second->SetWriteThreadHandle(f_hwritethread);
      }
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// SetWriteThreadHandle
/// Pass the handle of the write thread to the object of file/folder persistence
////////////////////////////////////////////////////////////////////////////////////////////////
VOID CPersistenceManager::SetNorPersistenceThreadHandle(HANDLE f_hwritethread) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (NULL != f_hwritethread) {   // LCOV_EXCL_BR_LINE 6: f_hwritethread would not be null
    m_hNSImmediatePersistenceThread = f_hwritethread;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

////////////////////////////////////////////////////////////////////////////////////////////
/// NPServiceOnCpWorkerAckCmd
/// Handles when the CopyWorker sends an ack back for a message received .
////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus NPServiceOnCpWorkerAckCmd(HANDLE f_happ) {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;
  NSP_CopyAckMsg l_tack = {};
  if (f_happ) {   // LCOV_EXCL_BR_LINE 4: NSFW error case.
    if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(f_happ, (PVOID)&l_tack, sizeof(NSP_CopyAckMsg), eSMRRelease))) {  // LCOV_EXCL_BR_LINE 4: NSFW error case  // NOLINT[whitespace/line_length]  // NOLINT[whitespace/line_length]
      FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "CP_WRK_ACK_CMD_COMPLETE for cmd 0x%X", l_tack.m_eworkerprotocol);  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"  // NOLINT[whitespace/line_length]
    } else {
      // LCOV_EXCL_START 4: NSFW error case.
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Unable to get message data in NPServiceOnCpWorkerAckCmd, status : 0x%x", l_estatus);
      // LCOV_EXCL_STOP
    }
  } else {
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_estatus = eFrameworkunifiedStatusNullPointer;  // LCOV_EXCL_LINE 4: NSFW error case.
  }

  return l_estatus;
}


////////////////////////////////////////////////////////////////////////////////////////////
/// SetUserPersistentPath
///
////////////////////////////////////////////////////////////////////////////////////////////
VOID CPersistenceManager::SetUserPersistentPath(std::string f_cusername) {
  m_cNotificationUserMemFilepath = CPersistence::GetStoragePath();
  m_cNotificationUserMemFilepath += AppName;
  m_cNotificationUserMemFilepath += "/";
  m_cNotificationUserMemFilepath += f_cusername;
  m_cNotificationUserMemFilepath += "/";
  m_cNotificationUserMemFilepath += m_cUserNotificationTag;
}

////////////////////////////////////////////////////////////////////////////////////////////
/// IsUserPersistence
/// Check if tag is user persistence
////////////////////////////////////////////////////////////////////////////////////////////
BOOL CPersistenceManager::IsUserPersistence(std::string f_ctag, ENotificationpersistentservicePersistType f_epersisttype) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  BOOL l_bUserPersistence = FALSE;

  // check boundary conditions
  if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) {  // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
    if (NULL != m_mPersist_Type[f_epersisttype]) {  // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] can't be null  // NOLINT[whitespace/line_length]
      // load file
      l_bUserPersistence = m_mPersist_Type[f_epersisttype]->IsUserPersistence(f_ctag);    // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT[whitespace/line_length]
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype);  // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] can't be null  // NOLINT[whitespace/line_length]
    }
  } else {
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype);   // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_bUserPersistence;
}

////////////////////////////////////////////////////////////////////////////////////////////
/// HaveAllReleaseRequestsPersisted
/// Check if all release requests processed or not
////////////////////////////////////////////////////////////////////////////////////////////
BOOL CPersistenceManager::HaveAllReleaseRequestsPersisted() {
  BOOL l_bRetVal = TRUE;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  // check if all files are persisted
  if (FALSE == m_bAllFilePersisted) {
    ENotificationpersistentservicePersistType l_ePersistType = ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST;
    l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1);

    std::string l_cTagNotReleased = "";
    std::string l_cTagList = "";    // LCOV_EXCL_BR_LINE 11:except,C++ STL

    // Persist all i.e files and folders
    while (l_ePersistType < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) {
      if (NULL != m_mPersist_Type[l_ePersistType]) {
        l_cTagNotReleased.assign("");   // LCOV_EXCL_BR_LINE 11:except,C++ STL
        // if(eFrameworkunifiedStatusFail == m_mPersist_Type[l_ePersistType]->PersistAllReleaseRequests())
        if (FALSE == m_mPersist_Type[l_ePersistType]->HaveAllReleaseRequestsPersisted(l_cTagNotReleased)) {
          l_bRetVal = FALSE;
          l_cTagList.append(l_cTagNotReleased);
        }
      } else {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", l_ePersistType);  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"  // NOLINT[whitespace/line_length]
      }

      l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1);
    }

    if (0 != l_cTagList.size()) {
      FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Tags not released:: %s", l_cTagList.c_str());
    }
  }

  if (TRUE == l_bRetVal) {
    m_bAllFilePersisted = TRUE;

    // if all files are persisted set the return value to the status of immediate data persistency
    l_bRetVal = m_bImmediatedDataPersisted;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_bRetVal;
}

////////////////////////////////////////////////////////////////////////////////////////////
/// ResetPersistFlag
///
////////////////////////////////////////////////////////////////////////////////////////////
VOID CPersistenceManager::ResetPersistFlag() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  ENotificationpersistentservicePersistType l_ePersistType = ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST;
  l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1);

  // Persist all i.e files and folders
  while (l_ePersistType < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) {
    if (NULL != m_mPersist_Type[l_ePersistType]) {
      m_mPersist_Type[l_ePersistType]->ResetPersistFlag();
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", l_ePersistType);  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"  // NOLINT[whitespace/line_length]
    }

    l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1);
  }

  m_bAllFilePersisted = FALSE;

  m_bImmediatedDataPersisted = FALSE;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceReadNorNotificationData
/// Get the list of all user persistent notifications from a persistent memory and store it in a map.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceReadNorNotificationData(Persistent_Notification_List_Type
                                                           * &f_vpersistentnotificationlist) {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (eFrameworkunifiedStatusOK != ReadImmediateNotificationData(f_vpersistentnotificationlist, eFrameworkunifiedUserData)) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No Immediate User data in persistent memory");  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"  // NOLINT[whitespace/line_length]
  }

  if (eFrameworkunifiedStatusOK != ReadImmediateNotificationData(f_vpersistentnotificationlist, eFrameworkunifiedFactoryData)) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No Immediate Factory data in persistent memory");  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"  // NOLINT[whitespace/line_length]
  }

  if (eFrameworkunifiedStatusOK != ReadImmediateNotificationData(f_vpersistentnotificationlist, eFrameworkunifiedFactoryCustomerData)) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No Immediate Factory Customer data in persistent memory");  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"  // NOLINT[whitespace/line_length]
  }

  if (eFrameworkunifiedStatusOK != ReadImmediateNotificationData(f_vpersistentnotificationlist, eFrameworkunifiedDealerData)) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No Immediate Dealer data in persistent memory");  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"  // NOLINT[whitespace/line_length]
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// ClearPersistenceData
/// Deletes the data from the persistent memory.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::ClearPersistenceData(const EFrameworkunifiedClearPersistence &f_enotificationpersistentserviceclearpersistencescope) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;

  // persistence memory path to be cleared
  std::string l_cPath = "";

  switch (f_enotificationpersistentserviceclearpersistencescope) {  // LCOV_EXCL_BR_LINE 6: f_enotificationpersistentserviceclearpersistencescope must be eFrameworkunifiedClearAllData, eFrameworkunifiedClearAllApplicationData, eFrameworkunifiedClearAllNotificationData, eFrameworkunifiedClearCurrentUserData, eFrameworkunifiedClearCurrentUserApplicationData, eFrameworkunifiedClearCurrentUserNotificationData.  // NOLINT[whitespace/line_length]
    case eFrameworkunifiedClearAllData: {
        // clears all the data from the persistent memory
        l_cPath.append(CPersistence::GetStoragePath());
      }
      break;

    case eFrameworkunifiedClearAllApplicationData: {
        // TODO(my_username): clears all the application folder in persistence memory
        // don't delete the NS_NPS folder
      }
      break;

    case eFrameworkunifiedClearAllNotificationData: {
        // TODO(my_username): deletes the NS_NPS folder
      }
      break;

    case eFrameworkunifiedClearCurrentUserData: {
        // TODO(my_username): deletes the user folder from all the application folder in persisted memory
        // as well as from the NS_NPS folder
      }
      break;

    case eFrameworkunifiedClearCurrentUserApplicationData: {
        // TODO(my_username): deletes the user folder from all the application folder
      }
      break;

    case eFrameworkunifiedClearCurrentUserNotificationData: {
        // TODO(my_username): deletes the user folder from the NS_NPS folder
      }
      break;

    default: {
        // LCOV_EXCL_START 6: f_enotificationpersistentserviceclearpersistencescope must be eFrameworkunifiedClearAllData, eFrameworkunifiedClearAllApplicationData, eFrameworkunifiedClearAllNotificationData, eFrameworkunifiedClearCurrentUserData, eFrameworkunifiedClearCurrentUserApplicationData, eFrameworkunifiedClearCurrentUserNotificationData.  // NOLINT[whitespace/line_length]
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Invalid _EFrameworkunifiedClearPersistence Parameter:: %d", f_enotificationpersistentserviceclearpersistencescope);
        l_estatus = eFrameworkunifiedStatusInvldParam;
        // LCOV_EXCL_STOP
      }
      break;
  }

  if (0 != l_cPath.size()) {
    if (CFSDirectory::DoesDirecotryExist(l_cPath)) {
      if (TRUE == CFSDirectory::RemoveDirectory(l_cPath)) {  // LCOV_EXCL_BR_LINE 6: RemoveDirectory always return ok
        FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Delete persistent directory successful : %s", l_cPath.c_str());
      } else {
        // LCOV_EXCL_START 6: RemoveDirectory always return ok
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Delete persistent directory unsuccessful : %s", l_cPath.c_str());
        l_estatus = eFrameworkunifiedStatusErrOther;
        // LCOV_EXCL_STOP
      }
    }
  } else {
    l_estatus = eFrameworkunifiedStatusErrOther;
  }

  // delete NOR data
  l_cPath.clear();
  l_cPath.append(IMMEDIATE_PERSISTENCE_STORAGE_V2);
  if (0 != l_cPath.size()) {  // LCOV_EXCL_BR_LINE 6: l_cPath.size can't be 0
    if (CFSDirectory::DoesDirecotryExist(l_cPath)) {
      if (TRUE == CFSDirectory::RemoveDirectory(l_cPath)) {  // LCOV_EXCL_BR_LINE 6: RemoveDirectory always return ok
        FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Delete nor persistent directory successful : %s", l_cPath.c_str());
      } else {
        // LCOV_EXCL_START 6: RemoveDirectory always return ok
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Delete nor persistent directory unsuccessful : %s", l_cPath.c_str());
        l_estatus = eFrameworkunifiedStatusErrOther;
        // LCOV_EXCL_STOP
      }
    }
  } else {
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_estatus = eFrameworkunifiedStatusErrOther;  // LCOV_EXCL_LINE 6: l_cPath.size can't be 0
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// NotificationpersistentserviceSetPersistentCategory
/// Sets the persist type of file or folder.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceSetPersistentCategory(std::string f_crequestorname,
                                                         std::string f_ctag,
                                                         EFrameworkunifiedPersistCategory f_epersistcategory,
                                                         ENotificationpersistentservicePersistType f_epersisttype) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;

  if (f_ctag.empty()) {  // LCOV_EXCL_BR_LINE 6: double check, f_ctag.size can't be empty
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Tag name is empty.");  // LCOV_EXCL_LINE 6: double check, f_ctag.size can't be empty
  } else {
    // check boundary conditions
    if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) {  // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
      if (NULL != m_mPersist_Type[f_epersisttype]) {  // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] can't be null  // NOLINT[whitespace/line_length]
        // set the persist type
        l_estatus = m_mPersist_Type[f_epersisttype]->SetPersistentCategory(f_crequestorname,
                                                                           f_ctag,
                                                                           f_epersistcategory);
      } else {
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype);  // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] can't be null  // NOLINT[whitespace/line_length]
      }
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype);  // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST  // NOLINT[whitespace/line_length]
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// PersistNORData
/// Sends the message to Immediate Persistence Thread to Persists the data immediately or reset
/// the NOR data depending on persist category flag during shutdown irrespective of delay.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::PersistNORData(EFrameworkunifiedShutdownType f_eshutdowntype, UI_32 f_uinotificationpersistentservicepersistcategoryflag) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;

  TImmediateShutdown l_tImmShutdown = {};
  l_tImmShutdown.f_eshutdowntype = f_eshutdowntype;
  l_tImmShutdown.f_uinotificationpersistentservicepersistcategoryflag = f_uinotificationpersistentservicepersistcategoryflag;

  // send the message to NOR to persist or reset the data during shutdown
  if (NULL != CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) {    // LCOV_EXCL_BR_LINE 4: NSFW error case.  // NOLINT[whitespace/line_length]
    if (eFrameworkunifiedStatusOK != (l_estatus = McSend(CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread, AppName, NOR_PERSISTENCE_ONSHUTDOWN, sizeof(l_tImmShutdown), &l_tImmShutdown))) {  // LCOV_EXCL_BR_LINE 4: NSFW error case  // NOLINT[whitespace/line_length]
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McSend for cmd 0x%X failed", NOR_PERSISTENCE_ONSHUTDOWN);   // LCOV_EXCL_LINE 4: NSFW error case.  // NOLINT[whitespace/line_length]
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

////////////////////////////////////////////////////////////////////////////////////////////
/// SetImmediateDataPersistedStatus
/// Set/Reset the persistence status of immediate persistence data
///////////////////////////////////////////////////////////////////////////////////////////
VOID CPersistenceManager::SetImmediateDataPersistedStatus(BOOL f_bstatus) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  m_bImmediatedDataPersisted = f_bstatus;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

////////////////////////////////////////////////////////////////////////////////////////////
/// SetFilePersistedStatus
/// Set/Reset the persistence status of files and folders
///////////////////////////////////////////////////////////////////////////////////////////
VOID CPersistenceManager::SetFilePersistedStatus(BOOL f_bstatus) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  m_bAllFilePersisted = f_bstatus;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// ReadImmediateNotificationData
/// Get the list of all immediate persistent notifications of f_epersistcategory from a
/// persistent memory and store it in a map.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CPersistenceManager::ReadImmediateNotificationData(Persistent_Notification_List_Type
                                                              * &f_vpersistentnotificationlist,
                                                              const EFrameworkunifiedPersistCategory f_epersistcategory) {
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  std::string l_pcPath = IMMEDIATE_PERSISTENCE_STORAGE_V2;
  std::string l_cNotificationName = "";   // LCOV_EXCL_BR_LINE 11:except,C++ STL
  // stores the list of invalid immediate notification files at persistent location
  std::string l_cInvalidFileList = "";    // LCOV_EXCL_BR_LINE 11:except,C++ STL

  PCSTR l_pPublisherName = NULL;
  PSTR l_pData = NULL;
  UI_32 l_uiDataSize = 0;

  NC_NorPersistentData l_ptNorPersistentData = {};

  TFileList l_pTFileList;

  if ('/' != l_pcPath[l_pcPath.length() - 1]) {   // LCOV_EXCL_BR_LINE 6: the last char is always '/'
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_pcPath.append("/");   // LCOV_EXCL_LINE 6: the last char is always '/'
  }

  switch (f_epersistcategory) {
    case eFrameworkunifiedFactoryData: {
        l_pcPath.append(FACTORYDATADIR);  // LCOV_EXCL_BR_LINE 11:except,C++ STL
      }
      break;

    case eFrameworkunifiedFactoryCustomerData: {
        l_pcPath.append(FACTORYCUSTOMERDATADIR);  // LCOV_EXCL_BR_LINE 11:except,C++ STL
      }
      break;

    case eFrameworkunifiedDealerData: {
        l_pcPath.append(DEALERDATADIR);   // LCOV_EXCL_BR_LINE 11:except,C++ STL
      }
      break;

    case eFrameworkunifiedUserData:
    default: {
        l_pcPath.append(USERDATADIR);   // LCOV_EXCL_BR_LINE 11:except,C++ STL
        l_pcPath.append(ALLUSERAPPDATADIR);   // LCOV_EXCL_BR_LINE 11:except,C++ STL
      }
      break;
  }

  l_pcPath.append(IMMEDIATEDATADIR);    // LCOV_EXCL_BR_LINE 11:except,C++ STL

  if (eFrameworkunifiedStatusOK == GetFileList(&l_pTFileList, l_pcPath.c_str())) {   // LCOV_EXCL_BR_LINE 4: NSFW error case.
    if (!l_pTFileList.empty()) {  // LCOV_EXCL_BR_LINE 200: if GetFileList() returns eFrameworkunifiedStatusOK, l_pTFileList can't be empty  // NOLINT[whitespace/line_length]
      for (UI_32 l_uiCount = 0; l_uiCount < l_pTFileList.size(); l_uiCount++) {
        l_uiDataSize = 0;

        // get the persistent notification name from vector
        l_cNotificationName = l_pTFileList.at(l_uiCount);

        if (eFrameworkunifiedStatusOK == NPSynchronousGetPersistentDataSize(l_cNotificationName.c_str(), &l_uiDataSize,  // LCOV_EXCL_BR_LINE 4: NSFW error case.  // NOLINT[whitespace/line_length]
                                                               f_epersistcategory) && (0 != l_uiDataSize)) {
          l_pData = new(std::nothrow) CHAR[l_uiDataSize];
          std::memset(l_pData, 0, l_uiDataSize);

          if (NULL != l_pData) {  // LCOV_EXCL_BR_LINE 6: l_pData can't be null
            l_pPublisherName = NULL;

            // clear the memory
            std::memset(&l_ptNorPersistentData, 0, sizeof(NC_NorPersistentData));

            // As NS_NPP does a recursive filename read from directory it has the complete filename.
            // So it does not require to pass the Publisher name i.e. l_pPublisherName.So it is being passed as NULL.
            if (eFrameworkunifiedStatusOK == NPSynchronousGetPersistentData(l_pPublisherName,  // LCOV_EXCL_BR_LINE 4: NSFW error case.  // NOLINT[whitespace/line_length]
                                                               l_cNotificationName.c_str(),
                                                               (PVOID)l_pData,
                                                               l_uiDataSize,
                                                               l_ptNorPersistentData,
                                                               f_epersistcategory)) {
              CNotificationsToPersist *l_objCNotificationsToPersist = new(std::nothrow) CNotificationsToPersist();
              if (NULL != l_objCNotificationsToPersist) {  // LCOV_EXCL_BR_LINE 6: l_objCNotificationsToPersist can't be null  // NOLINT[whitespace/line_length]
                CPersistentData *l_objCPersistentData = new(std::nothrow) CPersistentData();

                // fill the appropriate values in  l_objCNotificationsToPersist
                if (NULL != l_objCPersistentData) {  // LCOV_EXCL_BR_LINE 6: l_objCPersistentData can't be null
                  l_objCPersistentData->m_pMessage = new(std::nothrow) CHAR[l_ptNorPersistentData.dataSize];
                  std::memset(l_objCPersistentData->m_pMessage, 0, l_ptNorPersistentData.dataSize);

                  if (NULL != l_objCPersistentData->m_pMessage) {  // LCOV_EXCL_BR_LINE 6: l_objCPersistentData->m_pMessage can't be null  // NOLINT[whitespace/line_length]
                    std::memcpy(l_objCPersistentData->m_pMessage, l_pData, l_ptNorPersistentData.dataSize);

                    l_objCNotificationsToPersist->m_uiMaxMsgLength = l_ptNorPersistentData.uiMaxSize;
                    l_objCPersistentData->m_uiMsgSize = l_ptNorPersistentData.dataSize;
                    l_objCNotificationsToPersist->m_ePersistentType = eFrameworkunifiedImmediatePersistedStateVar;

                    l_objCNotificationsToPersist->m_cNotificationName = l_ptNorPersistentData.notificationName;
                    l_objCNotificationsToPersist->m_cPublisherName = l_ptNorPersistentData.pPublisherName;
                    l_objCNotificationsToPersist->m_uiDelay = l_ptNorPersistentData.uiDelay;

                    l_objCNotificationsToPersist->m_pPersistentData = l_objCPersistentData;

                    l_objCNotificationsToPersist->m_ePersistCategory = f_epersistcategory;

                    f_vpersistentnotificationlist->push_back(l_objCNotificationsToPersist);
                  } else {
                    // LCOV_EXCL_START 6: l_objCPersistentData->m_pMessage can't be null
                    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                    FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Memory allocation error for notification data of size %d",
                           l_ptNorPersistentData.dataSize);

                    if (NULL != l_objCNotificationsToPersist) {
                      delete l_objCNotificationsToPersist;
                      l_objCNotificationsToPersist = NULL;
                    }

                    if (NULL != l_objCPersistentData) {
                      delete l_objCPersistentData;
                      l_objCPersistentData = NULL;
                    }
                    // LCOV_EXCL_STOP
                  }
                } else {
                  // LCOV_EXCL_START 6: l_objCPersistentData can't be null
                  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                  FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Memory allocation error for CPersistentData object");

                  if (NULL != l_objCNotificationsToPersist) {
                    delete l_objCNotificationsToPersist;
                    l_objCNotificationsToPersist = NULL;
                  }
                  // LCOV_EXCL_STOP
                }
              } else {
                AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Memory allocation error for CNotificationsToPersist object");  // LCOV_EXCL_LINE 6: l_objCNotificationsToPersist can't be null  // NOLINT[whitespace/line_length]
              }
            } else {
              // LCOV_EXCL_START 4: NSFW error case.
              AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
              l_cInvalidFileList.append(l_cNotificationName);
              l_cInvalidFileList.append(",");
              // LCOV_EXCL_STOP
            }

            delete[] l_pData;
            l_pData = NULL;
          } else {
            // LCOV_EXCL_START 6: l_pData can't be null
            AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
            FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Persistent data received as NULL from immediate notification file :: %s",
                   l_cNotificationName.c_str());
            // LCOV_EXCL_STOP
          }
        } else {
          // LCOV_EXCL_START 4: NSFW error case.
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          l_cInvalidFileList.append(l_cNotificationName);
          l_cInvalidFileList.append(",");
          // LCOV_EXCL_STOP
        }
      }

      if (0 != l_cInvalidFileList.size()) {  // LCOV_EXCL_START 200: l_cInvalidFileList's size must be 0
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
               "Unable to get persistent data for following immediate notification files :: %s",
               l_cInvalidFileList.c_str());
      }
      // LCOV_EXCL_STOP
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "No Immediate persistence data available at :: %s", l_pcPath.c_str());  // LCOV_EXCL_LINE 200: if GetFileList() returns eFrameworkunifiedStatusOK, l_pTFileList can't be empty  // NOLINT[whitespace/line_length]
    }
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to get the list of files from Immediate persistent location :: %s",
           l_pcPath.c_str());
    l_estatus = eFrameworkunifiedStatusFail;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

#ifdef NPP_PROFILEINFO_ENABLE

EFrameworkunifiedStatus CPersistenceManager::GetPersistenceProfilingData(std::string &f_cpersistenceprofileinfo) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK;

  f_cpersistenceprofileinfo.append("Application Name,");
  f_cpersistenceprofileinfo.append("Tag Name,");
  f_cpersistenceprofileinfo.append("Type,");
  f_cpersistenceprofileinfo.append("UserSpecific,");
  f_cpersistenceprofileinfo.append("Released,");
  f_cpersistenceprofileinfo.append("Persisted");

  CPersistence *l_pPersistence = m_mPersist_Type[ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE];
  l_pPersistence->GetPersistenceProfilingData(f_cpersistenceprofileinfo);

  l_pPersistence = m_mPersist_Type[ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER];
  l_pPersistence->GetPersistenceProfilingData(f_cpersistenceprofileinfo);

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_estatus;
}

#endif