libH/FileEventWatcher.hpp

Go to the documentation of this file.

/*
  
  Copyright (c) 2007, Tim Burrell
  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. 
  
*/

#ifndef __FileEventWatcher_h
#define __FileEventWatcher_h

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include <cstdlib>
#include <string>
#include <list>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <sys/poll.h>
#include <map>
#include "DynamicBuffer.hpp"
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

// Namespace

namespace H {

// Typedef, enum's
        
typedef enum {
        WATCH_INVALID = -1,
        WATCH_IN,
        WATCH_OUT,
        WATCH_INOUT
} FileWatchType;

typedef enum {
        WATCH_POLL,
        WATCH_INOTIFY
} FileDeviceType;

// DeviceInfo Class Definition

class DeviceInfo {
public:
        // public member variables
        int                             DeviceIDBusType;        
        int                             DeviceIDProduct;        
        int                             DeviceIDVendor;         
        int                             DeviceIDVersion;        
        std::string                     DeviceName;             
        int                             FileDescriptor;         
        std::string                     FileName;               
                
        // construction / deconstruction
        DeviceInfo();                                           
        DeviceInfo(const DeviceInfo & DeviceInformation);       
        DeviceInfo(std::string DeviceName, std::string FileName, int DeviceIDBusType, int DeviceIDVendor, int DeviceIDProduct, int DeviceIDVersion, int FileDescriptor); 
        virtual ~DeviceInfo();                                  
        
private: 
        // serialization
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version) {
                ar & DeviceIDBusType;
                ar & DeviceIDProduct;
                ar & DeviceIDVendor;
                ar & DeviceIDVersion;
                ar & DeviceName;
                ar & FileDescriptor;
                ar & FileName;
        }       
};

// FileWatchee Class Definition

class FileWatchee : public DeviceInfo {
public:
        // public member variables
        FileDeviceType                  DeviceType;             
        short                           Events;                 
        int                             fd;                     
        FileWatchType                   WatchType;              
        int                             wd;                     
                
        // construction / deconstruction
        FileWatchee();                                          
        FileWatchee(std::string fileName, FileWatchType watchType, short events, int fileDescriptor, int watchDescriptor, std::string deviceName, int deviceIDBusType, int deviceIDVendor, int deviceIDProduct, int deviceIDVersion); 
        virtual ~FileWatchee();                                 
};

// FileEventWatcher Class Definition

class FileEventWatcher {
public:
        // public functions
        boost::shared_ptr<FileWatchee>  addFileToWatch(std::string FileName, FileWatchType WatchType, std::string DefaultDeviceName = "Unknown"); 
        boost::shared_ptr<FileWatchee>  addUnixSocketToWatch(std::string FileName, std::string DeviceName); 
        boost::shared_ptr<FileWatchee>  getWatcheeByFileDescriptor(int fd); 
        boost::shared_ptr<FileWatchee>  getWatcheeByPath(std::string Path); 
        boost::shared_ptr<FileWatchee>  getWatcheeByWatchDescriptor(int wd); 
        virtual void                    onFileEventCreate(boost::shared_ptr<FileWatchee> pWatchee, std::string FullPath, std::string FileName); 
        virtual void                    onFileEventDelete(boost::shared_ptr<FileWatchee> pWatchee, std::string FullPath, std::string FileName); 
        virtual void                    onFileEventDisconnect(boost::shared_ptr<FileWatchee> pWatchee); 
        virtual void                    onFileEventRead(boost::shared_ptr<FileWatchee> pWatchee, DynamicBuffer<char> const & ReadBuffer); 
        virtual void                    onFileEventRegister(boost::shared_ptr<FileWatchee> pWatchee); 
        virtual void                    onFileEventWatchBegin();        
        virtual void                    onFileEventWatchEnd();          
        void                            removeWatchee(boost::shared_ptr<FileWatchee> pWatchee); 
        void                            shutdown();                     
        void                            watchForFileEvents();           
        
        // construction / deconstruction
        FileEventWatcher();                                             
        virtual ~FileEventWatcher();                                    

private:
        // private functions
        void                            buildPollFDArrayFromWatchees(); 
        void                            buildPollFDArrayFunctor(std::pair< int, boost::shared_ptr<FileWatchee> > WatcheePair); 
        FileWatchType                   getType(int Index);             
        void                            handleEventsOnFile(struct pollfd & item); 
        void                            readFromFile(int fd, DynamicBuffer<char> & Buffer); 
        void                            removeAllWatchDescriptors();    
        void                            removeWatchDescriptor(int wd);  
        
        // private member variables
        int                             mInotifyFD;                     
        std::vector<int>                mInotifyWDs;                    
        std::vector<struct pollfd>      mPollFDs;                       
        bool                            mPolling;                       
        std::map< int, boost::shared_ptr<FileWatchee> > mWatchees;      
};

// Exception Classes

class DeviceDisconnectException : public std::exception {
};

class WatcheeNotFoundException : public std::exception {
};


}

#endif // __FileEventWatcher_h

---