FileSystemWatcher.h

#pragma once

#if !defined(PARAENGINE_MOBILE)

#include "dir_monitor/basic_dir_monitor.hpp"
#include <boost/thread.hpp>
#include <queue>

namespace ParaEngine
{

    class CFileSystemWatcher
    {
    public:
        typedef boost::asio::dir_monitor_event::event_type FileActionEnum;
        typedef boost::asio::dir_monitor_event DirMonitorEvent;
        typedef boost::signals2::signal<void(const DirMonitorEvent&)>  FileSystemEvent_t;
        typedef boost::signals2::connection FileSystemEvent_Connection_t;
        
        CFileSystemWatcher(const std::string& filename);
        CFileSystemWatcher();
        ~CFileSystemWatcher();

    public:
        void Destroy();

        bool add_directory(const std::string &dirname);

        bool remove_directory(const std::string &dirname);

        int DispatchEvents();

        void SetDispatchInMainThread(bool bMainThread);

        bool IsDispatchInMainThread();

        FileSystemEvent_Connection_t AddEventCallback(FileSystemEvent_t::slot_type callback);

        const std::string& GetName() const;
        void SetName(const std::string& val);
    private:
        void FileHandler(const boost::system::error_code &ec, const boost::asio::dir_monitor_event &ev);

        std::queue < DirMonitorEvent > m_msg_queue;

        void* m_monitor_imp;

        ParaEngine::mutex m_mutex;

        FileSystemEvent_t m_file_event;

        std::string m_name;

        bool m_bDispatchInMainThread;
    };
    typedef boost::shared_ptr<CFileSystemWatcher> CFileSystemWatcherPtr;

    class CFileSystemWatcherService : public CRefCounted
    {
    public:
        typedef std::map<std::string, CFileSystemWatcherPtr > file_watcher_map_t;

        CFileSystemWatcherService();
        virtual ~CFileSystemWatcherService();

        static CFileSystemWatcherService* GetInstance();

        void Clear();

        CFileSystemWatcherPtr GetDirWatcher(const std::string& name);

        void DeleteDirWatcher(const std::string& name);

        int DispatchEvents();

        boost::asio::io_service& GetIOService() {return *(m_io_service.get());}

        bool IsStarted() {return m_bIsStarted;}

        bool Start();
    protected:
        int fileWatcherThreadMain();
    private:
        file_watcher_map_t m_file_watchers;

        boost::shared_ptr<boost::asio::io_service> m_io_service;
        boost::scoped_ptr<boost::asio::io_service::work> m_io_service_work;
        boost::shared_ptr< boost::thread > m_work_thread;
        bool m_bIsStarted;
    };

}
#else
namespace ParaEngine
{
    // empty implementation
    class CFileSystemWatcher
    {
    public:
    };
}
#endif