WebSVN - public - Diff - Rev 69 and 84 - /incron/tags/incron-0.5.7/incrontab.h



/// inotify cron table manipulator classes header
/**
 * \file incrontab.h
 *
 * inotify cron system
 *
 * Copyright (C) 2006, 2007 Lukas Jelinek, <lukas@aiken.cz>
 *
 * This program is free software; you can use it, redistribute
 * it and/or modify it under the terms of the GNU General Public
 * License, version 2 (see LICENSE-GPL).
 *  
 */


#ifndef _INCRONTAB_H_
#define _INCRONTAB_H_

#include <string>
#include <deque>

#include "strtok.h"

/*
/// Incron user table base directory
#define INCRON_USER_TABLE_BASE "/var/spool/incron/"

/// Incron system table base directory
#define INCRON_SYS_TABLE_BASE "/etc/incron.d/"
*/

/// Incron table entry class.
class IncronTabEntry
{
public:
  /// Constructor.
  /**
   * Creates an empty entry for later use with Parse().
   *
   * \sa Parse()
   */
  IncronTabEntry();

  /// Constructor.
  /**
   * Creates an entry based on defined parameters.
   *
   * \param[in] rPath watched filesystem path
   * \param[in] uMask event mask
   * \param[in] rCmd command string
   */
  IncronTabEntry(const std::string& rPath, uint32_t uMask, const std::string& rCmd);
 
  /// Destructor.
  ~IncronTabEntry() {}
 
  /// Converts the entry to string representation.
  /**
   * This method creates a string for use in a table file.
   *
   * \return string representation
   */
  std::string ToString() const;
 
  /// Parses a string and attempts to extract entry parameters.
  /**
   * \param[in] rStr parsed string
   * \param[out] rEntry parametrized entry
   * \return true = success, false = failure
   */
  static bool Parse(const std::string& rStr, IncronTabEntry& rEntry);
 
  /// Returns the watch filesystem path.
  /**
   * \return watch path
   */
  inline const std::string& GetPath() const
  {
    return m_path;
  }
 
  /// Returns the event mask.
  /**
   * \return event mask
   */
  inline int32_t GetMask() const
  {
    return m_uMask;
  }
 
  /// Returns the command string.
  /**
   * \return command string
   */
  inline const std::string& GetCmd() const
  {
    return m_cmd;
  }
 
  /// Checks whether this entry has set loop-avoidance.
  /**
   * \return true = no loop, false = loop allowed
   */
  inline bool IsNoLoop() const
  {
    return m_fNoLoop;
  }
 
  /// Add backslashes before spaces in the source path.
  /**
   * It also adds backslashes before all original backslashes
   * of course.
   *
   * The source string is not modified and a copy is returned
   * instead.
   *
   * This method is intended to be used for paths in user tables.
   *
   * \param[in] rPath path to be modified
   * \return modified path
   */
  static std::string GetSafePath(const std::string& rPath);
 
protected:
  std::string m_path; ///< watch path
  uint32_t m_uMask;   ///< event mask
  std::string m_cmd;  ///< command string
  bool m_fNoLoop;     ///< no loop yes/no
};


/// Incron table class.
class IncronTab
{
public:
  /// Constructor.
  IncronTab() {}
 
  /// Destructor.
  ~IncronTab() {}
 
  /// Add an entry to the table.
  /**
   * \param[in] rEntry table entry
   */
  inline void Add(const IncronTabEntry& rEntry)
  {
    m_tab.push_back(rEntry);
  }
 
  /// Removes all entries.
  inline void Clear()
  {
    m_tab.clear();
  }
 
  /// Checks whether the table is empty.
  /**
   * \return true = empty, false = otherwise
   */
  inline bool IsEmpty() const
  {
    return m_tab.empty();
  }
 
  /// Returns the count of entries.
  /**
   * \return count of entries
   */
  inline int GetCount() const
  {
    return (int) m_tab.size();
  }
 
  /// Returns an entry.
  /**
   * \return reference to the entry for the given index
   *
   * \attention This method doesn't test index bounds. If you
   *            pass an invalid value the program may crash
   *            and/or behave unpredictible way!
   */
  inline IncronTabEntry& GetEntry(int index)
  {
    return m_tab[index];
  }
 
  /// Loads the table.
  /**
   * \param[in] rPath path to a source table file
   * \return true = success, false = failure
   */
  bool Load(const std::string& rPath);
 
  /// Saves the table.
  /**
   * \param[in] rPath path to a destination table file
   * \return true = success, false = failure
   */
  bool Save(const std::string& rPath);
 
  /// Checks whether an user has permission to use incron.
  /**
   * \param[in] rUser user name
   * \return true = permission OK, false = otherwise
   */
  static bool CheckUser(const std::string& rUser);
 
  /// Composes a path to an user incron table file.
  /**
   * \param[in] rUser user name
   * \return path to the table file
   *
   * \attention No tests (existence, permission etc.) are done.
   */
  static std::string GetUserTablePath(const std::string& rUser);
 
  /// Composes a path to a system incron table file.
  /**
   * \param[in] rName table name (pseudouser)
   * \return path to the table file
   *
   * \attention No tests (existence, permission etc.) are done.
   */
  static std::string GetSystemTablePath(const std::string& rName);

protected:
  std::deque<IncronTabEntry> m_tab; ///< incron table
};


#endif //_INCRONTAB_H_
 

Rev 69	Rev 84
1		1
2	/// inotify cron table manipulator classes header	2	/// inotify cron table manipulator classes header
3	/**	3	/**
4	* \file incrontab.h	4	* \file incrontab.h
5	*	5	*
6	* inotify cron system	6	* inotify cron system
7	*	7	*
8	* Copyright (C) 2006, 2007 Lukas Jelinek, <lukas@aiken.cz>	8	* Copyright (C) 2006, 2007 Lukas Jelinek, <lukas@aiken.cz>
9	*	9	*
10	* This program is free software; you can use it, redistribute	10	* This program is free software; you can use it, redistribute
11	* it and/or modify it under the terms of the GNU General Public	11	* it and/or modify it under the terms of the GNU General Public
12	* License, version 2 (see LICENSE-GPL).	12	* License, version 2 (see LICENSE-GPL).
13	*	13	*
14	*/	14	*/
15		15
16		16
17	#ifndef _INCRONTAB_H_	17	#ifndef _INCRONTAB_H_
18	#define _INCRONTAB_H_	18	#define _INCRONTAB_H_
19		19
20	#include <string>	20	#include <string>
21	#include <deque>	21	#include <deque>
22		22
23	#include "strtok.h"	23	#include "strtok.h"
24		24
25	/*	25	/*
26	/// Incron user table base directory	26	/// Incron user table base directory
27	#define INCRON_USER_TABLE_BASE "/var/spool/incron/"	27	#define INCRON_USER_TABLE_BASE "/var/spool/incron/"
28		28
29	/// Incron system table base directory	29	/// Incron system table base directory
30	#define INCRON_SYS_TABLE_BASE "/etc/incron.d/"	30	#define INCRON_SYS_TABLE_BASE "/etc/incron.d/"
31	*/	31	*/
32		32
33	/// Incron table entry class.	33	/// Incron table entry class.
34	class IncronTabEntry	34	class IncronTabEntry
35	{	35	{
36	public:	36	public:
37	/// Constructor.	37	/// Constructor.
38	/**	38	/**
39	* Creates an empty entry for later use with Parse().	39	* Creates an empty entry for later use with Parse().
40	*	40	*
41	* \sa Parse()	41	* \sa Parse()
42	*/	42	*/
43	IncronTabEntry();	43	IncronTabEntry();
44		44
45	/// Constructor.	45	/// Constructor.
46	/**	46	/**
47	* Creates an entry based on defined parameters.	47	* Creates an entry based on defined parameters.
48	*	48	*
49	* \param[in] rPath watched filesystem path	49	* \param[in] rPath watched filesystem path
50	* \param[in] uMask event mask	50	* \param[in] uMask event mask
51	* \param[in] rCmd command string	51	* \param[in] rCmd command string
52	*/	52	*/
53	IncronTabEntry(const std::string& rPath, uint32_t uMask, const std::string& rCmd);	53	IncronTabEntry(const std::string& rPath, uint32_t uMask, const std::string& rCmd);
54		54
55	/// Destructor.	55	/// Destructor.
56	~IncronTabEntry() {}	56	~IncronTabEntry() {}
57		57
58	/// Converts the entry to string representation.	58	/// Converts the entry to string representation.
59	/**	59	/**
60	* This method creates a string for use in a table file.	60	* This method creates a string for use in a table file.
61	*	61	*
62	* \return string representation	62	* \return string representation
63	*/	63	*/
64	std::string ToString() const;	64	std::string ToString() const;
65		65
66	/// Parses a string and attempts to extract entry parameters.	66	/// Parses a string and attempts to extract entry parameters.
67	/**	67	/**
68	* \param[in] rStr parsed string	68	* \param[in] rStr parsed string
69	* \param[out] rEntry parametrized entry	69	* \param[out] rEntry parametrized entry
70	* \return true = success, false = failure	70	* \return true = success, false = failure
71	*/	71	*/
72	static bool Parse(const std::string& rStr, IncronTabEntry& rEntry);	72	static bool Parse(const std::string& rStr, IncronTabEntry& rEntry);
73		73
74	/// Returns the watch filesystem path.	74	/// Returns the watch filesystem path.
75	/**	75	/**
76	* \return watch path	76	* \return watch path
77	*/	77	*/
78	inline const std::string& GetPath() const	78	inline const std::string& GetPath() const
79	{	79	{
80	return m_path;	80	return m_path;
81	}	81	}
82		82
83	/// Returns the event mask.	83	/// Returns the event mask.
84	/**	84	/**
85	* \return event mask	85	* \return event mask
86	*/	86	*/
87	inline int32_t GetMask() const	87	inline int32_t GetMask() const
88	{	88	{
89	return m_uMask;	89	return m_uMask;
90	}	90	}
91		91
92	/// Returns the command string.	92	/// Returns the command string.
93	/**	93	/**
94	* \return command string	94	* \return command string
95	*/	95	*/
96	inline const std::string& GetCmd() const	96	inline const std::string& GetCmd() const
97	{	97	{
98	return m_cmd;	98	return m_cmd;
99	}	99	}
100		100
101	/// Checks whether this entry has set loop-avoidance.	101	/// Checks whether this entry has set loop-avoidance.
102	/**	102	/**
103	* \return true = no loop, false = loop allowed	103	* \return true = no loop, false = loop allowed
104	*/	104	*/
105	inline bool IsNoLoop() const	105	inline bool IsNoLoop() const
106	{	106	{
107	return m_fNoLoop;	107	return m_fNoLoop;
108	}	108	}
109		109
110	/// Add backslashes before spaces in the source path.	110	/// Add backslashes before spaces in the source path.
111	/**	111	/**
112	* It also adds backslashes before all original backslashes	112	* It also adds backslashes before all original backslashes
113	* of course.	113	* of course.
114	*	114	*
115	* The source string is not modified and a copy is returned	115	* The source string is not modified and a copy is returned
116	* instead.	116	* instead.
117	*	117	*
118	* This method is intended to be used for paths in user tables.	118	* This method is intended to be used for paths in user tables.
119	*	119	*
120	* \param[in] rPath path to be modified	120	* \param[in] rPath path to be modified
121	* \return modified path	121	* \return modified path
122	*/	122	*/
123	static std::string GetSafePath(const std::string& rPath);	123	static std::string GetSafePath(const std::string& rPath);
124		124
125	protected:	125	protected:
126	std::string m_path; ///< watch path	126	std::string m_path; ///< watch path
127	uint32_t m_uMask; ///< event mask	127	uint32_t m_uMask; ///< event mask
128	std::string m_cmd; ///< command string	128	std::string m_cmd; ///< command string
129	bool m_fNoLoop; ///< no loop yes/no	129	bool m_fNoLoop; ///< no loop yes/no
130	};	130	};
131		131
132		132
133	/// Incron table class.	133	/// Incron table class.
134	class IncronTab	134	class IncronTab
135	{	135	{
136	public:	136	public:
137	/// Constructor.	137	/// Constructor.
138	IncronTab() {}	138	IncronTab() {}
139		139
140	/// Destructor.	140	/// Destructor.
141	~IncronTab() {}	141	~IncronTab() {}
142		142
143	/// Add an entry to the table.	143	/// Add an entry to the table.
144	/**	144	/**
145	* \param[in] rEntry table entry	145	* \param[in] rEntry table entry
146	*/	146	*/
147	inline void Add(const IncronTabEntry& rEntry)	147	inline void Add(const IncronTabEntry& rEntry)
148	{	148	{
149	m_tab.push_back(rEntry);	149	m_tab.push_back(rEntry);
150	}	150	}
151		151
152	/// Removes all entries.	152	/// Removes all entries.
153	inline void Clear()	153	inline void Clear()
154	{	154	{
155	m_tab.clear();	155	m_tab.clear();
156	}	156	}
157		157
158	/// Checks whether the table is empty.	158	/// Checks whether the table is empty.
159	/**	159	/**
160	* \return true = empty, false = otherwise	160	* \return true = empty, false = otherwise
161	*/	161	*/
162	inline bool IsEmpty() const	162	inline bool IsEmpty() const
163	{	163	{
164	return m_tab.empty();	164	return m_tab.empty();
165	}	165	}
166		166
167	/// Returns the count of entries.	167	/// Returns the count of entries.
168	/**	168	/**
169	* \return count of entries	169	* \return count of entries
170	*/	170	*/
171	inline int GetCount() const	171	inline int GetCount() const
172	{	172	{
173	return (int) m_tab.size();	173	return (int) m_tab.size();
174	}	174	}
175		175
176	/// Returns an entry.	176	/// Returns an entry.
177	/**	177	/**
178	* \return reference to the entry for the given index	178	* \return reference to the entry for the given index
179	*	179	*
180	* \attention This method doesn't test index bounds. If you	180	* \attention This method doesn't test index bounds. If you
181	* pass an invalid value the program may crash	181	* pass an invalid value the program may crash
182	* and/or behave unpredictible way!	182	* and/or behave unpredictible way!
183	*/	183	*/
184	inline IncronTabEntry& GetEntry(int index)	184	inline IncronTabEntry& GetEntry(int index)
185	{	185	{
186	return m_tab[index];	186	return m_tab[index];
187	}	187	}
188		188
189	/// Loads the table.	189	/// Loads the table.
190	/**	190	/**
191	* \param[in] rPath path to a source table file	191	* \param[in] rPath path to a source table file
192	* \return true = success, false = failure	192	* \return true = success, false = failure
193	*/	193	*/
194	bool Load(const std::string& rPath);	194	bool Load(const std::string& rPath);
195		195
196	/// Saves the table.	196	/// Saves the table.
197	/**	197	/**
198	* \param[in] rPath path to a destination table file	198	* \param[in] rPath path to a destination table file
199	* \return true = success, false = failure	199	* \return true = success, false = failure
200	*/	200	*/
201	bool Save(const std::string& rPath);	201	bool Save(const std::string& rPath);
202		202
203	/// Checks whether an user has permission to use incron.	203	/// Checks whether an user has permission to use incron.
204	/**	204	/**
205	* \param[in] rUser user name	205	* \param[in] rUser user name
206	* \return true = permission OK, false = otherwise	206	* \return true = permission OK, false = otherwise
207	*/	207	*/
208	static bool CheckUser(const std::string& rUser);	208	static bool CheckUser(const std::string& rUser);
209		209
210	/// Composes a path to an user incron table file.	210	/// Composes a path to an user incron table file.
211	/**	211	/**
212	* \param[in] rUser user name	212	* \param[in] rUser user name
213	* \return path to the table file	213	* \return path to the table file
214	*	214	*
215	* \attention No tests (existence, permission etc.) are done.	215	* \attention No tests (existence, permission etc.) are done.
216	*/	216	*/
217	static std::string GetUserTablePath(const std::string& rUser);	217	static std::string GetUserTablePath(const std::string& rUser);
218		218
219	/// Composes a path to a system incron table file.	219	/// Composes a path to a system incron table file.
220	/**	220	/**
221	* \param[in] rName table name (pseudouser)	221	* \param[in] rName table name (pseudouser)
222	* \return path to the table file	222	* \return path to the table file
223	*	223	*
224	* \attention No tests (existence, permission etc.) are done.	224	* \attention No tests (existence, permission etc.) are done.
225	*/	225	*/
226	static std::string GetSystemTablePath(const std::string& rName);	226	static std::string GetSystemTablePath(const std::string& rName);
227		227
228	protected:	228	protected:
229	std::deque<IncronTabEntry> m_tab; ///< incron table	229	std::deque<IncronTabEntry> m_tab; ///< incron table
230	};	230	};
231		231
232		232
233	#endif //_INCRONTAB_H_	233	#endif //_INCRONTAB_H_
234		234

Subversion Repositories public

(root)/incron/tags/incron-0.5.7/incrontab.h - Rev 69 → 84