monitor.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2021 Enrico M. Crisostomo
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 3, or (at your option) any later version.
 *
 * This program 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 General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef FSW__MONITOR_H
#  define FSW__MONITOR_H
 
#  include "libfswatch/libfswatch_config.h"
#  include "filter.hpp"
#  include <vector>
#  include <string>
#  ifdef HAVE_CXX_MUTEX
#    include <mutex>
#  endif
#  include <atomic>
#  include <chrono>
#  include <map>
#  include "event.hpp"
#  include "libfswatch/c/cmonitor.h"
 
namespace fsw
{
  typedef void FSW_EVENT_CALLBACK(const std::vector<event>&, void *);
 
  struct compiled_monitor_filter;
 
  class monitor
  {
  public:
    monitor(std::vector<std::string> paths,
            FSW_EVENT_CALLBACK *callback,
            void *context = nullptr);
 
    virtual ~monitor();
 
    monitor(const monitor& orig) = delete;
 
    monitor& operator=(const monitor& that) = delete;
 
    void set_property(const std::string& name, const std::string& value);
 
    void set_properties(const std::map<std::string, std::string> options);
 
    std::string get_property(std::string name);
 
    void set_latency(double latency);
 
    void set_fire_idle_event(bool fire_idle_event);
 
    void set_allow_overflow(bool overflow);
 
    void set_recursive(bool recursive);
 
    void set_directory_only(bool directory_only);
 
    void add_filter(const monitor_filter& filter);
 
    void set_filters(const std::vector<monitor_filter>& filters);
 
    void set_follow_symlinks(bool follow);
 
    void *get_context() const;
 
    void set_context(void *context);
 
    void set_bubble_events(bool bubble_events);
 
    void start();
 
    void stop();
 
    bool is_running();
 
    void add_event_type_filter(const fsw_event_type_filter& filter);
 
    void set_event_type_filters(
      const std::vector<fsw_event_type_filter>& filters);
 
    void set_watch_access(bool access);
 
  protected:
    bool accept_event_type(fsw_event_flag event_type) const;
 
    bool accept_path(const std::string& path) const;
 
    void notify_events(const std::vector<event>& events) const;
 
    void notify_overflow(const std::string& path) const;
 
    std::vector<fsw_event_flag> filter_flags(const event& evt) const;
 
    virtual void run() = 0;
 
    virtual void on_stop();
 
  protected:
    std::vector<std::string> paths;
 
    std::map<std::string, std::string> properties;
 
    FSW_EVENT_CALLBACK *callback;
 
    void *context = nullptr;
 
    double latency = 1.0;
 
    bool fire_idle_event = false;
 
    bool allow_overflow = false;
 
    bool recursive = false;
 
    bool follow_symlinks = false;
 
    bool directory_only = false;
 
    bool watch_access = false;
 
    bool running = false;
 
    bool should_stop = false;
 
    bool bubble_events = false;
 
#  ifdef HAVE_CXX_MUTEX
    mutable std::mutex run_mutex;
 
    mutable std::mutex notify_mutex;
#  endif
 
  private:
    std::chrono::milliseconds get_latency_ms() const;
    std::vector<compiled_monitor_filter> filters;
    std::vector<fsw_event_type_filter> event_type_filters;
 
#ifdef HAVE_CXX_MUTEX
# ifdef HAVE_CXX_ATOMIC
#   define HAVE_INACTIVITY_CALLBACK
    static void inactivity_callback(monitor *mon);
    mutable std::atomic<std::chrono::milliseconds> last_notification;
# endif
#endif
  };
}
 
#endif  /* FSW__MONITOR_H */