monitor.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2018 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 "filter.hpp"
#  include <vector>
#  include <string>
#  ifdef HAVE_CXX_MUTEX
#    include <mutex>
#  endif
#  include <atomic>
#  include <chrono>
#  include <map>
#  include "event.hpp"
#  include "../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 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;

#  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 */