2000-02-19 13:36:48 +01:00
|
|
|
/*
|
|
|
|
* tools.h: Various tools
|
|
|
|
*
|
2000-04-24 09:46:05 +02:00
|
|
|
* See the main source file 'vdr.c' for copyright information and
|
2000-02-19 13:36:48 +01:00
|
|
|
* how to reach the author.
|
|
|
|
*
|
2010-10-24 13:08:55 +02:00
|
|
|
* $Id: tools.h 2.5 2010/10/24 13:06:27 kls Exp $
|
2000-02-19 13:36:48 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __TOOLS_H
|
|
|
|
#define __TOOLS_H
|
|
|
|
|
2004-12-19 16:33:34 +01:00
|
|
|
#include <dirent.h>
|
2002-06-16 12:57:31 +02:00
|
|
|
#include <errno.h>
|
2000-09-17 08:23:46 +02:00
|
|
|
#include <fcntl.h>
|
2009-12-06 12:57:45 +01:00
|
|
|
#include <float.h>
|
2007-06-10 13:02:43 +02:00
|
|
|
#include <iconv.h>
|
2009-12-06 12:57:45 +01:00
|
|
|
#include <math.h>
|
2002-08-16 09:22:29 +02:00
|
|
|
#include <poll.h>
|
2005-01-04 11:09:51 +01:00
|
|
|
#include <stddef.h>
|
2006-12-02 11:30:19 +01:00
|
|
|
#include <stdint.h>
|
2000-03-11 11:22:37 +01:00
|
|
|
#include <stdio.h>
|
2007-06-10 13:02:43 +02:00
|
|
|
#include <stdlib.h>
|
2000-10-03 10:34:48 +02:00
|
|
|
#include <string.h>
|
2000-02-19 13:36:48 +01:00
|
|
|
#include <syslog.h>
|
2000-09-17 08:23:46 +02:00
|
|
|
#include <sys/stat.h>
|
2000-04-24 13:54:23 +02:00
|
|
|
#include <sys/types.h>
|
2000-02-19 13:36:48 +01:00
|
|
|
|
2002-06-16 12:57:31 +02:00
|
|
|
typedef unsigned char uchar;
|
|
|
|
|
2000-04-15 17:38:11 +02:00
|
|
|
extern int SysLogLevel;
|
|
|
|
|
2007-07-28 09:45:27 +02:00
|
|
|
#define esyslog(a...) void( (SysLogLevel > 0) ? syslog_with_tid(LOG_ERR, a) : void() )
|
|
|
|
#define isyslog(a...) void( (SysLogLevel > 1) ? syslog_with_tid(LOG_ERR, a) : void() )
|
|
|
|
#define dsyslog(a...) void( (SysLogLevel > 2) ? syslog_with_tid(LOG_ERR, a) : void() )
|
2000-04-15 17:38:11 +02:00
|
|
|
|
2002-05-13 16:35:49 +02:00
|
|
|
#define LOG_ERROR esyslog("ERROR (%s,%d): %m", __FILE__, __LINE__)
|
|
|
|
#define LOG_ERROR_STR(s) esyslog("ERROR: %s: %m", s)
|
2000-02-19 13:36:48 +01:00
|
|
|
|
2000-03-11 11:22:37 +01:00
|
|
|
#define SECSINDAY 86400
|
|
|
|
|
2001-09-14 14:35:40 +02:00
|
|
|
#define KILOBYTE(n) ((n) * 1024)
|
2009-04-18 09:37:54 +02:00
|
|
|
#define MEGABYTE(n) ((n) * 1024LL * 1024LL)
|
2001-09-14 14:35:40 +02:00
|
|
|
|
2002-08-11 13:32:23 +02:00
|
|
|
#define MALLOC(type, size) (type *)malloc(sizeof(type) * (size))
|
|
|
|
|
2000-03-11 11:22:37 +01:00
|
|
|
#define DELETENULL(p) (delete (p), p = NULL)
|
|
|
|
|
2002-06-16 12:57:31 +02:00
|
|
|
#define CHECK(s) { if ((s) < 0) LOG_ERROR; } // used for 'ioctl()' calls
|
2005-10-01 12:48:34 +02:00
|
|
|
#define FATALERRNO (errno && errno != EAGAIN && errno != EINTR)
|
2002-06-16 12:57:31 +02:00
|
|
|
|
2002-11-30 12:51:45 +01:00
|
|
|
#ifndef __STL_CONFIG_H // in case some plugin needs to use the STL
|
2001-09-14 14:06:43 +02:00
|
|
|
template<class T> inline T min(T a, T b) { return a <= b ? a : b; }
|
|
|
|
template<class T> inline T max(T a, T b) { return a >= b ? a : b; }
|
2002-09-08 11:46:53 +02:00
|
|
|
template<class T> inline int sgn(T a) { return a < 0 ? -1 : a > 0 ? 1 : 0; }
|
2001-09-14 14:06:43 +02:00
|
|
|
template<class T> inline void swap(T &a, T &b) { T t = a; a = b; b = t; }
|
2002-11-30 12:51:45 +01:00
|
|
|
#endif
|
2000-12-28 12:57:16 +01:00
|
|
|
|
2006-04-16 10:43:22 +02:00
|
|
|
void syslog_with_tid(int priority, const char *format, ...) __attribute__ ((format (printf, 2, 3)));
|
2006-01-15 16:42:37 +01:00
|
|
|
|
2004-01-11 15:54:37 +01:00
|
|
|
#define BCDCHARTOINT(x) (10 * ((x & 0xF0) >> 4) + (x & 0xF))
|
|
|
|
int BCD2INT(int x);
|
|
|
|
|
2005-08-21 14:15:00 +02:00
|
|
|
// Unfortunately there are no platform independent macros for unaligned
|
2009-12-06 12:57:45 +01:00
|
|
|
// access, so we do it this way:
|
2005-08-21 14:15:00 +02:00
|
|
|
|
|
|
|
template<class T> inline T get_unaligned(T *p)
|
|
|
|
{
|
|
|
|
struct s { T v; } __attribute__((packed));
|
|
|
|
return ((s *)p)->v;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<class T> inline void put_unaligned(unsigned int v, T* p)
|
|
|
|
{
|
|
|
|
struct s { T v; } __attribute__((packed));
|
|
|
|
((s *)p)->v = v;
|
|
|
|
}
|
|
|
|
|
2009-12-06 12:57:45 +01:00
|
|
|
// Comparing doubles for equality is unsafe, but unfortunately we can't
|
|
|
|
// overwrite operator==(double, double), so this will have to do:
|
|
|
|
|
|
|
|
inline bool DoubleEqual(double a, double b)
|
|
|
|
{
|
|
|
|
return fabs(a - b) <= DBL_EPSILON;
|
|
|
|
}
|
|
|
|
|
2007-06-10 13:02:43 +02:00
|
|
|
// When handling strings that might contain UTF-8 characters, it may be necessary
|
|
|
|
// to process a "symbol" that consists of several actual character bytes. The
|
|
|
|
// following functions allow transparently accessing a "char *" string without
|
|
|
|
// having to worry about what character set is actually used.
|
|
|
|
|
|
|
|
int Utf8CharLen(const char *s);
|
|
|
|
///< Returns the number of character bytes at the beginning of the given
|
|
|
|
///< string that form a UTF-8 symbol.
|
|
|
|
uint Utf8CharGet(const char *s, int Length = 0);
|
|
|
|
///< Returns the UTF-8 symbol at the beginning of the given string.
|
|
|
|
///< Length can be given from a previous call to Utf8CharLen() to avoid calculating
|
|
|
|
///< it again. If no Length is given, Utf8CharLen() will be called.
|
|
|
|
int Utf8CharSet(uint c, char *s = NULL);
|
|
|
|
///< Converts the given UTF-8 symbol to a sequence of character bytes and copies
|
|
|
|
///< them to the given string. Returns the number of bytes written. If no string
|
|
|
|
///< is given, only the number of bytes is returned and nothing is copied.
|
|
|
|
int Utf8SymChars(const char *s, int Symbols);
|
|
|
|
///< Returns the number of character bytes at the beginning of the given
|
2007-06-15 12:24:06 +02:00
|
|
|
///< string that form at most the given number of UTF-8 symbols.
|
2007-06-16 09:05:22 +02:00
|
|
|
int Utf8StrLen(const char *s);
|
2007-06-15 12:24:06 +02:00
|
|
|
///< Returns the number of UTF-8 symbols formed by the given string of
|
|
|
|
///< character bytes.
|
2007-06-16 10:41:21 +02:00
|
|
|
char *Utf8Strn0Cpy(char *Dest, const char *Src, int n);
|
|
|
|
///< Copies at most n character bytes from Src to Dst, making sure that the
|
|
|
|
///< resulting copy ends with a complete UTF-8 symbol. The copy is guaranteed
|
|
|
|
///< to be zero terminated.
|
|
|
|
///< Returns a pointer to Dest.
|
2007-06-10 13:02:43 +02:00
|
|
|
int Utf8ToArray(const char *s, uint *a, int Size);
|
|
|
|
///< Converts the given character bytes (including the terminating 0) into an
|
|
|
|
///< array of UTF-8 symbols of the given Size. Returns the number of symbols
|
|
|
|
///< in the array (without the terminating 0).
|
|
|
|
int Utf8FromArray(const uint *a, char *s, int Size, int Max = -1);
|
|
|
|
///< Converts the given array of UTF-8 symbols (including the terminating 0)
|
|
|
|
///< into a sequence of character bytes of at most Size length. Returns the
|
|
|
|
///< number of character bytes written (without the terminating 0).
|
|
|
|
///< If Max is given, only that many symbols will be converted.
|
|
|
|
///< The resulting string is always zero-terminated if Size is big enough.
|
|
|
|
|
|
|
|
// When allocating buffer space, make sure we reserve enough space to hold
|
|
|
|
// a string in UTF-8 representation:
|
|
|
|
|
|
|
|
#define Utf8BufSize(s) ((s) * 4)
|
|
|
|
|
|
|
|
// The following macros automatically use the correct versions of the character
|
|
|
|
// class functions:
|
|
|
|
|
|
|
|
#define Utf8to(conv, c) (cCharSetConv::SystemCharacterTable() ? to##conv(c) : tow##conv(c))
|
|
|
|
#define Utf8is(ccls, c) (cCharSetConv::SystemCharacterTable() ? is##ccls(c) : isw##ccls(c))
|
|
|
|
|
|
|
|
class cCharSetConv {
|
|
|
|
private:
|
|
|
|
iconv_t cd;
|
|
|
|
char *result;
|
|
|
|
size_t length;
|
|
|
|
static char *systemCharacterTable;
|
|
|
|
public:
|
|
|
|
cCharSetConv(const char *FromCode = NULL, const char *ToCode = NULL);
|
|
|
|
///< Sets up a character set converter to convert from FromCode to ToCode.
|
2009-12-23 15:25:05 +01:00
|
|
|
///< If FromCode is NULL, the previously set systemCharacterTable is used
|
|
|
|
///< (or "UTF-8" if no systemCharacterTable has been set).
|
2007-06-10 13:02:43 +02:00
|
|
|
///< If ToCode is NULL, "UTF-8" is used.
|
|
|
|
~cCharSetConv();
|
|
|
|
const char *Convert(const char *From, char *To = NULL, size_t ToLength = 0);
|
2008-05-22 10:26:57 +02:00
|
|
|
///< Converts the given Text from FromCode to ToCode (as set in the constructor).
|
2007-06-10 13:02:43 +02:00
|
|
|
///< If To is given, it is used to copy at most ToLength bytes of the result
|
|
|
|
///< (including the terminating 0) into that buffer. If To is not given,
|
|
|
|
///< the result is copied into a dynamically allocated buffer and is valid as
|
|
|
|
///< long as this object lives, or until the next call to Convert(). The
|
|
|
|
///< return value always points to the result if the conversion was successful
|
|
|
|
///< (even if a fixed size To buffer was given and the result didn't fit into
|
|
|
|
///< it). If the string could not be converted, the result points to the
|
|
|
|
///< original From string.
|
|
|
|
static const char *SystemCharacterTable(void) { return systemCharacterTable; }
|
|
|
|
static void SetSystemCharacterTable(const char *CharacterTable);
|
|
|
|
};
|
|
|
|
|
2004-12-26 12:45:22 +01:00
|
|
|
class cString {
|
|
|
|
private:
|
|
|
|
char *s;
|
|
|
|
public:
|
2005-02-05 10:12:14 +01:00
|
|
|
cString(const char *S = NULL, bool TakePointer = false);
|
2005-11-26 14:16:02 +01:00
|
|
|
cString(const cString &String);
|
2004-12-26 12:45:22 +01:00
|
|
|
virtual ~cString();
|
2008-02-17 13:47:12 +01:00
|
|
|
operator const void * () const { return s; } // to catch cases where operator*() should be used
|
2004-12-26 12:45:22 +01:00
|
|
|
operator const char * () const { return s; } // for use in (const char *) context
|
|
|
|
const char * operator*() const { return s; } // for use in (const void *) context (printf() etc.)
|
|
|
|
cString &operator=(const cString &String);
|
2010-10-24 13:08:55 +02:00
|
|
|
cString &operator=(const char *String);
|
2008-01-13 11:26:30 +01:00
|
|
|
cString &Truncate(int Index); ///< Truncate the string at the given Index (if Index is < 0 it is counted from the end of the string).
|
2005-10-09 11:14:14 +02:00
|
|
|
static cString sprintf(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
|
2008-02-15 14:57:48 +01:00
|
|
|
static cString sprintf(const char *fmt, va_list &ap);
|
2004-12-26 12:45:22 +01:00
|
|
|
};
|
|
|
|
|
2001-08-12 15:22:48 +02:00
|
|
|
ssize_t safe_read(int filedes, void *buffer, size_t size);
|
|
|
|
ssize_t safe_write(int filedes, const void *buffer, size_t size);
|
2000-04-15 17:38:11 +02:00
|
|
|
void writechar(int filedes, char c);
|
2005-01-16 12:02:39 +01:00
|
|
|
int WriteAllOrNothing(int fd, const uchar *Data, int Length, int TimeoutMs = 0, int RetryMs = 0);
|
|
|
|
///< Writes either all Data to the given file descriptor, or nothing at all.
|
|
|
|
///< If TimeoutMs is greater than 0, it will only retry for that long, otherwise
|
|
|
|
///< it will retry forever. RetryMs defines the time between two retries.
|
2001-09-22 13:07:43 +02:00
|
|
|
char *strcpyrealloc(char *dest, const char *src);
|
2000-09-09 14:57:43 +02:00
|
|
|
char *strn0cpy(char *dest, const char *src, size_t n);
|
2000-07-16 15:02:33 +02:00
|
|
|
char *strreplace(char *s, char c1, char c2);
|
2002-12-15 15:36:02 +01:00
|
|
|
char *strreplace(char *s, const char *s1, const char *s2); ///< re-allocates 's' and deletes the original string if necessary!
|
2007-07-21 13:39:02 +02:00
|
|
|
inline char *skipspace(const char *s)
|
|
|
|
{
|
2007-07-28 12:59:48 +02:00
|
|
|
if ((uchar)*s > ' ') // most strings don't have any leading space, so handle this case as fast as possible
|
2007-07-21 13:39:02 +02:00
|
|
|
return (char *)s;
|
2007-07-28 12:59:48 +02:00
|
|
|
while (*s && (uchar)*s <= ' ') // avoiding isspace() here, because it is much slower
|
2007-07-21 13:39:02 +02:00
|
|
|
s++;
|
|
|
|
return (char *)s;
|
|
|
|
}
|
2000-11-11 16:38:41 +01:00
|
|
|
char *stripspace(char *s);
|
2001-08-17 13:19:10 +02:00
|
|
|
char *compactspace(char *s);
|
2004-12-26 12:45:22 +01:00
|
|
|
cString strescape(const char *s, const char *chars);
|
2001-08-17 13:19:10 +02:00
|
|
|
bool startswith(const char *s, const char *p);
|
2002-01-20 16:47:09 +01:00
|
|
|
bool endswith(const char *s, const char *p);
|
2000-10-29 13:17:22 +01:00
|
|
|
bool isempty(const char *s);
|
2002-10-19 15:33:37 +02:00
|
|
|
int numdigits(int n);
|
2000-07-23 15:01:31 +02:00
|
|
|
bool isnumber(const char *s);
|
2004-12-26 12:45:22 +01:00
|
|
|
cString itoa(int n);
|
|
|
|
cString AddDirectory(const char *DirName, const char *FileName);
|
2008-02-16 13:38:22 +01:00
|
|
|
bool EntriesOnSameFileSystem(const char *File1, const char *File2);
|
2002-01-27 13:11:23 +01:00
|
|
|
int FreeDiskSpaceMB(const char *Directory, int *UsedMB = NULL);
|
2000-07-29 15:21:42 +02:00
|
|
|
bool DirectoryOk(const char *DirName, bool LogErrors = false);
|
2000-04-15 17:38:11 +02:00
|
|
|
bool MakeDirs(const char *FileName, bool IsDirectory = false);
|
2000-07-29 15:21:42 +02:00
|
|
|
bool RemoveFileOrDir(const char *FileName, bool FollowSymlinks = false);
|
2001-02-11 14:53:44 +01:00
|
|
|
bool RemoveEmptyDirectories(const char *DirName, bool RemoveThis = false);
|
2005-12-18 10:41:26 +01:00
|
|
|
int DirSizeMB(const char *DirName); ///< returns the total size of the files in the given directory, or -1 in case of an error
|
2005-09-18 09:33:40 +02:00
|
|
|
char *ReadLink(const char *FileName); ///< returns a new string allocated on the heap, which the caller must delete (or NULL in case of an error)
|
2001-08-11 11:15:41 +02:00
|
|
|
bool SpinUpDisk(const char *FileName);
|
2005-09-25 13:49:31 +02:00
|
|
|
void TouchFile(const char *FileName);
|
2004-06-13 20:26:51 +02:00
|
|
|
time_t LastModifiedTime(const char *FileName);
|
2004-12-26 12:45:22 +01:00
|
|
|
cString WeekDayName(int WeekDay);
|
|
|
|
cString WeekDayName(time_t t);
|
2007-06-23 13:40:04 +02:00
|
|
|
cString WeekDayNameFull(int WeekDay);
|
|
|
|
cString WeekDayNameFull(time_t t);
|
2004-12-26 12:45:22 +01:00
|
|
|
cString DayDateTime(time_t t = 0);
|
|
|
|
cString TimeToString(time_t t);
|
2005-05-16 14:45:11 +02:00
|
|
|
cString DateString(time_t t);
|
|
|
|
cString TimeString(time_t t);
|
2005-12-29 11:24:02 +01:00
|
|
|
uchar *RgbToJpeg(uchar *Mem, int Width, int Height, int &Size, int Quality = 100);
|
|
|
|
///< Converts the given Memory to a JPEG image and returns a pointer
|
|
|
|
///< to the resulting image. Mem must point to a data block of exactly
|
|
|
|
///< (Width * Height) triplets of RGB image data bytes. Upon return, Size
|
|
|
|
///< will hold the number of bytes of the resulting JPEG data.
|
|
|
|
///< Quality can be in the range 0..100 and controls the quality of the
|
|
|
|
///< resulting image, where 100 is "best". The caller takes ownership of
|
|
|
|
///< the result and has to delete it once it is no longer needed.
|
|
|
|
///< The result may be NULL in case of an error.
|
2004-12-19 16:33:34 +01:00
|
|
|
|
2005-12-29 16:02:37 +01:00
|
|
|
class cBase64Encoder {
|
|
|
|
private:
|
|
|
|
const uchar *data;
|
|
|
|
int length;
|
|
|
|
int maxResult;
|
|
|
|
int i;
|
|
|
|
char *result;
|
|
|
|
static const char *b64;
|
|
|
|
public:
|
|
|
|
cBase64Encoder(const uchar *Data, int Length, int MaxResult = 64);
|
|
|
|
///< Sets up a new base 64 encoder for the given Data, with the given Length.
|
2005-12-30 11:27:23 +01:00
|
|
|
///< Data will not be copied and must be valid as long as NextLine() will be
|
|
|
|
///< called. MaxResult defines the maximum number of characters in any
|
2005-12-29 16:02:37 +01:00
|
|
|
///< result line. The resulting lines may be shorter than MaxResult in case
|
|
|
|
///< its value is not a multiple of 4.
|
|
|
|
~cBase64Encoder();
|
|
|
|
const char *NextLine(void);
|
|
|
|
///< Returns the next line of encoded data (terminated by '\0'), or NULL if
|
|
|
|
///< there is no more encoded data. The caller must call NextLine() and process
|
|
|
|
///< each returned line until NULL is returned, in order to get the entire
|
2005-12-30 11:27:23 +01:00
|
|
|
///< data encoded. The returned data is only valid until the next time NextLine()
|
|
|
|
///< is called, or until the object is destroyed.
|
2005-12-29 16:02:37 +01:00
|
|
|
};
|
|
|
|
|
2004-12-19 18:08:09 +01:00
|
|
|
class cTimeMs {
|
|
|
|
private:
|
2006-12-02 11:30:19 +01:00
|
|
|
uint64_t begin;
|
2004-12-19 18:08:09 +01:00
|
|
|
public:
|
2007-01-07 14:46:14 +01:00
|
|
|
cTimeMs(int Ms = 0);
|
|
|
|
///< Creates a timer with ms resolution and an initial timeout of Ms.
|
2006-12-02 11:30:19 +01:00
|
|
|
static uint64_t Now(void);
|
2004-12-19 18:08:09 +01:00
|
|
|
void Set(int Ms = 0);
|
|
|
|
bool TimedOut(void);
|
2006-12-02 11:30:19 +01:00
|
|
|
uint64_t Elapsed(void);
|
2004-12-19 18:08:09 +01:00
|
|
|
};
|
|
|
|
|
2004-12-19 16:33:34 +01:00
|
|
|
class cReadLine {
|
|
|
|
private:
|
2005-11-04 17:18:33 +01:00
|
|
|
size_t size;
|
|
|
|
char *buffer;
|
2004-12-19 16:33:34 +01:00
|
|
|
public:
|
2005-11-04 17:18:33 +01:00
|
|
|
cReadLine(void);
|
|
|
|
~cReadLine();
|
2004-12-19 16:33:34 +01:00
|
|
|
char *Read(FILE *f);
|
|
|
|
};
|
2000-03-11 11:22:37 +01:00
|
|
|
|
2002-08-16 09:22:29 +02:00
|
|
|
class cPoller {
|
|
|
|
private:
|
|
|
|
enum { MaxPollFiles = 16 };
|
|
|
|
pollfd pfd[MaxPollFiles];
|
|
|
|
int numFileHandles;
|
|
|
|
public:
|
|
|
|
cPoller(int FileHandle = -1, bool Out = false);
|
|
|
|
bool Add(int FileHandle, bool Out);
|
|
|
|
bool Poll(int TimeoutMs = 0);
|
|
|
|
};
|
2006-01-08 11:44:37 +01:00
|
|
|
|
2004-12-19 16:33:34 +01:00
|
|
|
class cReadDir {
|
|
|
|
private:
|
|
|
|
DIR *directory;
|
|
|
|
struct dirent *result;
|
|
|
|
union { // according to "The GNU C Library Reference Manual"
|
|
|
|
struct dirent d;
|
|
|
|
char b[offsetof(struct dirent, d_name) + NAME_MAX + 1];
|
|
|
|
} u;
|
|
|
|
public:
|
|
|
|
cReadDir(const char *Directory);
|
|
|
|
~cReadDir();
|
|
|
|
bool Ok(void) { return directory != NULL; }
|
|
|
|
struct dirent *Next(void);
|
|
|
|
};
|
|
|
|
|
2000-09-17 08:23:46 +02:00
|
|
|
class cFile {
|
|
|
|
private:
|
|
|
|
static bool files[];
|
|
|
|
static int maxFiles;
|
|
|
|
int f;
|
|
|
|
public:
|
|
|
|
cFile(void);
|
|
|
|
~cFile();
|
|
|
|
operator int () { return f; }
|
2005-08-06 09:56:08 +02:00
|
|
|
bool Open(const char *FileName, int Flags, mode_t Mode = DEFFILEMODE);
|
2000-09-17 08:23:46 +02:00
|
|
|
bool Open(int FileDes);
|
|
|
|
void Close(void);
|
|
|
|
bool IsOpen(void) { return f >= 0; }
|
|
|
|
bool Ready(bool Wait = true);
|
|
|
|
static bool AnyFileReady(int FileDes = -1, int TimeoutMs = 1000);
|
2000-10-08 09:25:20 +02:00
|
|
|
static bool FileReady(int FileDes, int TimeoutMs = 1000);
|
2001-06-02 10:47:40 +02:00
|
|
|
static bool FileReadyForWriting(int FileDes, int TimeoutMs = 1000);
|
2000-09-17 08:23:46 +02:00
|
|
|
};
|
|
|
|
|
2001-01-13 15:36:31 +01:00
|
|
|
class cSafeFile {
|
|
|
|
private:
|
|
|
|
FILE *f;
|
|
|
|
char *fileName;
|
|
|
|
char *tempName;
|
|
|
|
public:
|
|
|
|
cSafeFile(const char *FileName);
|
|
|
|
~cSafeFile();
|
|
|
|
operator FILE* () { return f; }
|
|
|
|
bool Open(void);
|
2001-09-16 08:57:58 +02:00
|
|
|
bool Close(void);
|
2001-01-13 15:36:31 +01:00
|
|
|
};
|
|
|
|
|
2005-10-31 13:14:26 +01:00
|
|
|
/// cUnbufferedFile is used for large files that are mainly written or read
|
|
|
|
/// in a streaming manner, and thus should not be cached.
|
|
|
|
|
|
|
|
class cUnbufferedFile {
|
|
|
|
private:
|
|
|
|
int fd;
|
2006-02-04 14:12:17 +01:00
|
|
|
off_t curpos;
|
|
|
|
off_t cachedstart;
|
|
|
|
off_t cachedend;
|
2005-10-31 13:14:26 +01:00
|
|
|
off_t begin;
|
2006-02-04 14:12:17 +01:00
|
|
|
off_t lastpos;
|
2005-10-31 13:14:26 +01:00
|
|
|
off_t ahead;
|
2006-02-04 14:12:17 +01:00
|
|
|
size_t readahead;
|
|
|
|
size_t written;
|
|
|
|
size_t totwritten;
|
2006-02-04 14:21:08 +01:00
|
|
|
int FadviseDrop(off_t Offset, off_t Len);
|
2005-10-31 13:14:26 +01:00
|
|
|
public:
|
|
|
|
cUnbufferedFile(void);
|
|
|
|
~cUnbufferedFile();
|
|
|
|
int Open(const char *FileName, int Flags, mode_t Mode = DEFFILEMODE);
|
|
|
|
int Close(void);
|
2006-02-04 14:12:17 +01:00
|
|
|
void SetReadAhead(size_t ra);
|
2005-10-31 13:14:26 +01:00
|
|
|
off_t Seek(off_t Offset, int Whence);
|
|
|
|
ssize_t Read(void *Data, size_t Size);
|
|
|
|
ssize_t Write(const void *Data, size_t Size);
|
|
|
|
static cUnbufferedFile *Create(const char *FileName, int Flags, mode_t Mode = DEFFILEMODE);
|
|
|
|
};
|
|
|
|
|
2001-09-30 10:38:06 +02:00
|
|
|
class cLockFile {
|
|
|
|
private:
|
|
|
|
char *fileName;
|
|
|
|
int f;
|
|
|
|
public:
|
|
|
|
cLockFile(const char *Directory);
|
|
|
|
~cLockFile();
|
|
|
|
bool Lock(int WaitSeconds = 0);
|
|
|
|
void Unlock(void);
|
|
|
|
};
|
|
|
|
|
2000-02-19 13:36:48 +01:00
|
|
|
class cListObject {
|
|
|
|
private:
|
|
|
|
cListObject *prev, *next;
|
|
|
|
public:
|
|
|
|
cListObject(void);
|
|
|
|
virtual ~cListObject();
|
2004-11-01 10:40:38 +01:00
|
|
|
virtual int Compare(const cListObject &ListObject) const { return 0; }
|
|
|
|
///< Must return 0 if this object is equal to ListObject, a positive value
|
|
|
|
///< if it is "greater", and a negative value if it is "smaller".
|
2000-02-19 13:36:48 +01:00
|
|
|
void Append(cListObject *Object);
|
2002-05-12 14:46:46 +02:00
|
|
|
void Insert(cListObject *Object);
|
2000-02-19 13:36:48 +01:00
|
|
|
void Unlink(void);
|
2005-03-20 15:15:42 +01:00
|
|
|
int Index(void) const;
|
2000-10-29 13:17:22 +01:00
|
|
|
cListObject *Prev(void) const { return prev; }
|
|
|
|
cListObject *Next(void) const { return next; }
|
2000-02-19 13:36:48 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class cListBase {
|
|
|
|
protected:
|
|
|
|
cListObject *objects, *lastObject;
|
|
|
|
cListBase(void);
|
2005-05-26 11:41:33 +02:00
|
|
|
int count;
|
2000-02-19 13:36:48 +01:00
|
|
|
public:
|
|
|
|
virtual ~cListBase();
|
2002-05-12 14:46:46 +02:00
|
|
|
void Add(cListObject *Object, cListObject *After = NULL);
|
|
|
|
void Ins(cListObject *Object, cListObject *Before = NULL);
|
2002-05-19 15:50:11 +02:00
|
|
|
void Del(cListObject *Object, bool DeleteObject = true);
|
2000-04-15 17:38:11 +02:00
|
|
|
virtual void Move(int From, int To);
|
2000-03-11 11:22:37 +01:00
|
|
|
void Move(cListObject *From, cListObject *To);
|
2000-11-12 16:48:50 +01:00
|
|
|
virtual void Clear(void);
|
2000-10-29 13:17:22 +01:00
|
|
|
cListObject *Get(int Index) const;
|
2005-05-26 11:41:33 +02:00
|
|
|
int Count(void) const { return count; }
|
2001-08-26 14:17:20 +02:00
|
|
|
void Sort(void);
|
2000-02-19 13:36:48 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template<class T> class cList : public cListBase {
|
|
|
|
public:
|
2000-10-29 13:17:22 +01:00
|
|
|
T *Get(int Index) const { return (T *)cListBase::Get(Index); }
|
|
|
|
T *First(void) const { return (T *)objects; }
|
2000-12-28 12:57:16 +01:00
|
|
|
T *Last(void) const { return (T *)lastObject; }
|
2002-05-11 08:42:30 +02:00
|
|
|
T *Prev(const T *object) const { return (T *)object->cListObject::Prev(); } // need to call cListObject's members to
|
|
|
|
T *Next(const T *object) const { return (T *)object->cListObject::Next(); } // avoid ambiguities in case of a "list of lists"
|
2000-02-19 13:36:48 +01:00
|
|
|
};
|
|
|
|
|
2007-06-10 13:02:43 +02:00
|
|
|
template<class T> class cVector {
|
|
|
|
private:
|
|
|
|
mutable int allocated;
|
|
|
|
mutable int size;
|
|
|
|
mutable T *data;
|
2007-06-17 11:12:46 +02:00
|
|
|
cVector(const cVector &Vector) {} // don't copy...
|
|
|
|
cVector &operator=(const cVector &Vector) { return *this; } // ...or assign this!
|
|
|
|
void Realloc(int Index) const
|
|
|
|
{
|
|
|
|
if (++Index > allocated) {
|
|
|
|
data = (T *)realloc(data, Index * sizeof(T));
|
|
|
|
for (int i = allocated; i < Index; i++)
|
|
|
|
data[i] = T(0);
|
|
|
|
allocated = Index;
|
|
|
|
}
|
|
|
|
}
|
2007-06-10 13:02:43 +02:00
|
|
|
public:
|
|
|
|
cVector(int Allocated = 10)
|
|
|
|
{
|
|
|
|
allocated = 0;
|
|
|
|
size = 0;
|
|
|
|
data = NULL;
|
|
|
|
Realloc(Allocated);
|
|
|
|
}
|
|
|
|
virtual ~cVector() { free(data); }
|
|
|
|
T& At(int Index) const
|
|
|
|
{
|
2007-06-17 11:12:46 +02:00
|
|
|
Realloc(Index);
|
2007-06-10 13:02:43 +02:00
|
|
|
if (Index >= size)
|
2007-06-17 11:12:46 +02:00
|
|
|
size = Index + 1;
|
2007-06-10 13:02:43 +02:00
|
|
|
return data[Index];
|
|
|
|
}
|
|
|
|
const T& operator[](int Index) const
|
|
|
|
{
|
|
|
|
return At(Index);
|
|
|
|
}
|
|
|
|
T& operator[](int Index)
|
|
|
|
{
|
|
|
|
return At(Index);
|
|
|
|
}
|
|
|
|
int Size(void) const { return size; }
|
2007-06-17 11:12:46 +02:00
|
|
|
virtual void Insert(T Data, int Before = 0)
|
|
|
|
{
|
|
|
|
if (Before < size) {
|
|
|
|
Realloc(size);
|
|
|
|
memmove(&data[Before + 1], &data[Before], (size - Before) * sizeof(T));
|
|
|
|
size++;
|
|
|
|
data[Before] = Data;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Append(Data);
|
|
|
|
}
|
2007-06-10 13:02:43 +02:00
|
|
|
virtual void Append(T Data)
|
|
|
|
{
|
|
|
|
if (size >= allocated)
|
|
|
|
Realloc(allocated * 4 / 2); // increase size by 50%
|
|
|
|
data[size++] = Data;
|
|
|
|
}
|
2007-08-26 09:58:10 +02:00
|
|
|
virtual void Remove(int Index)
|
|
|
|
{
|
|
|
|
if (Index < size - 1)
|
|
|
|
memmove(&data[Index], &data[Index + 1], (size - Index) * sizeof(T));
|
|
|
|
size--;
|
|
|
|
}
|
2008-01-01 15:10:07 +01:00
|
|
|
virtual void Clear(void)
|
|
|
|
{
|
|
|
|
size = 0;
|
|
|
|
}
|
2007-06-10 13:02:43 +02:00
|
|
|
void Sort(__compar_fn_t Compare)
|
|
|
|
{
|
|
|
|
qsort(data, size, sizeof(T), Compare);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
inline int CompareStrings(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
return strcmp(*(const char **)a, *(const char **)b);
|
|
|
|
}
|
|
|
|
|
2007-06-17 11:12:46 +02:00
|
|
|
class cStringList : public cVector<char *> {
|
|
|
|
public:
|
|
|
|
cStringList(int Allocated = 10): cVector<char *>(Allocated) {}
|
|
|
|
virtual ~cStringList();
|
|
|
|
int Find(const char *s) const;
|
|
|
|
void Sort(void) { cVector<char *>::Sort(CompareStrings); }
|
|
|
|
virtual void Clear(void);
|
|
|
|
};
|
|
|
|
|
|
|
|
class cFileNameList : public cStringList {
|
2007-06-10 13:02:43 +02:00
|
|
|
public:
|
2007-08-11 12:39:06 +02:00
|
|
|
cFileNameList(const char *Directory = NULL, bool DirsOnly = false);
|
|
|
|
bool Load(const char *Directory, bool DirsOnly = false);
|
2007-06-10 13:02:43 +02:00
|
|
|
};
|
|
|
|
|
2005-05-28 13:17:20 +02:00
|
|
|
class cHashObject : public cListObject {
|
|
|
|
friend class cHashBase;
|
|
|
|
private:
|
2005-05-29 10:24:54 +02:00
|
|
|
unsigned int id;
|
2005-05-28 13:17:20 +02:00
|
|
|
cListObject *object;
|
|
|
|
public:
|
2005-05-29 10:24:54 +02:00
|
|
|
cHashObject(cListObject *Object, unsigned int Id) { object = Object; id = Id; }
|
2005-09-11 13:23:49 +02:00
|
|
|
cListObject *Object(void) { return object; }
|
2005-05-28 13:17:20 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
class cHashBase {
|
|
|
|
private:
|
|
|
|
cList<cHashObject> **hashTable;
|
|
|
|
int size;
|
2005-05-29 10:24:54 +02:00
|
|
|
unsigned int hashfn(unsigned int Id) const { return Id % size; }
|
2005-05-28 13:17:20 +02:00
|
|
|
protected:
|
|
|
|
cHashBase(int Size);
|
|
|
|
public:
|
|
|
|
virtual ~cHashBase();
|
2005-05-29 10:24:54 +02:00
|
|
|
void Add(cListObject *Object, unsigned int Id);
|
|
|
|
void Del(cListObject *Object, unsigned int Id);
|
2005-09-11 13:23:49 +02:00
|
|
|
void Clear(void);
|
2005-05-29 10:24:54 +02:00
|
|
|
cListObject *Get(unsigned int Id) const;
|
|
|
|
cList<cHashObject> *GetList(unsigned int Id) const;
|
2005-05-28 13:17:20 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
#define HASHSIZE 512
|
|
|
|
|
|
|
|
template<class T> class cHash : public cHashBase {
|
|
|
|
public:
|
|
|
|
cHash(int Size = HASHSIZE) : cHashBase(Size) {}
|
2005-05-29 10:24:54 +02:00
|
|
|
T *Get(unsigned int Id) const { return (T *)cHashBase::Get(Id); }
|
2005-05-28 13:17:20 +02:00
|
|
|
};
|
|
|
|
|
2000-02-19 13:36:48 +01:00
|
|
|
#endif //__TOOLS_H
|