FileWatcher.cpp

Go to the documentation of this file.

/*
  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

  This file is part of the TerraLib - a Framework for building GIS enabled
  applications.

  TerraLib is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License,
  or (at your option) any later version.

  TerraLib is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with TerraLib. See COPYING. If not, write to
  TerraLib Team at <terralib-team@terralib.org>.
 */

/*!
  \file terralib/core/filesystem/FileWatcher.cpp

  \brief This class is designed to watch a file.

  \author Matheus Cavassan Zaglia
 */

// TerraLib
#include "FileWatcher.h"
#include "../Exception.h"
#include "FileSystem.h"

// STL
#include <chrono>

te::core::FileWatcher::FileWatcher(const std::string &path,
                                   const std::function<void()> &callback)
    : m_file(path), m_callback(callback)
{
}

te::core::FileWatcher::~FileWatcher()
{
  m_watcher.join();
}

void te::core::FileWatcher::watch()
{
  m_watcher = std::thread([this]() {

    bool exists = false;
    exists = te::core::FileSystem::exists(m_file);

    uintmax_t fileSize = 0;
    if(exists)
      fileSize = te::core::FileSystem::fileSize(m_file);

    m_running = true;

    while(m_running)
    {
      std::this_thread::sleep_for(std::chrono::milliseconds(1000));

      bool tempExists = te::core::FileSystem::exists(m_file);
      if(tempExists != exists)
      {
        exists = tempExists;
        std::lock_guard<std::mutex> lock(m_mutex);
        m_callback();
        continue;
      }

      if(!exists)
        continue;

      uintmax_t tempSize = te::core::FileSystem::fileSize(m_file);
      if(fileSize != tempSize)
      {
        fileSize = tempSize;
        std::lock_guard<std::mutex> lock(m_mutex);
        m_callback();
        continue;
      }
    }

  });
}

void te::core::FileWatcher::unwatch()
{
  m_running = false;
}