b0VIM 7.3      ^M? 6  faust                                   hammer                                  ~faust/Projects/gssmd/include/syncer.h                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             3210    #"! U                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 tp           ;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ad  '
  /     ;                     ~  }  q  p  `  _  I  ;  :  ,               {  B  "                I  H  9  -  	              i  S  1            o  =  :  9  7  6  /  .                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         #endif  }  };         bool getDBData(std::string & data) const;         bool getSwitchesState(std::map<std::string, Switch> & switches);         Timer & getNextTimer();         void syncInfo();         bool wait();          std::list<TimedSwitch> _switches;         std::list<Timer> _timers;         Snmp & _snmp;         SettingsParser & _settingsParser;     private:          void run(const bool & running, bool & reload);          ~Syncer();                Snmp & snmp);         Syncer(SettingsParser & sp,     public: class Syncer {  typedef std::pair<Switch, TimerIterator> TimedSwitch; typedef std::list<Timer>::iterator TimerIterator;  };         boost::function<void ()> _callback;         time_t _lastFire;         time_t _interval;     private:         int getTimeout() const;         time_t getLastFire() const { return _lastFire; }         time_t getInterval() const { return _interval; }          void fire();          ~Timer();         Timer(boost::function<void ()> callback, time_t interval);     public: class Timer {  class Switch; class SettingsParser;  namespace GTS {  class Snmp;  #include <boost/function.hpp>  #include <map> #include <list> #include <ctime>  #define __GTS_SYNCER_H__ #ifndef __GTS_SYNCER_H__ 