1
0
mirror of https://github.com/VDR4Arch/vdr.git synced 2023-10-10 13:36:52 +02:00
vdr/tools.h

155 lines
4.6 KiB
C
Raw Normal View History

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.
*
* $Id: tools.h 1.42 2002/02/17 12:57:44 kls Exp $
2000-02-19 13:36:48 +01:00
*/
#ifndef __TOOLS_H
#define __TOOLS_H
2000-12-08 16:23:32 +01:00
//#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
2000-10-03 10:34:48 +02:00
#include <string.h>
2000-02-19 13:36:48 +01:00
#include <syslog.h>
#include <sys/stat.h>
2000-04-24 13:54:23 +02:00
#include <sys/types.h>
2000-02-19 13:36:48 +01:00
extern int SysLogLevel;
#define esyslog(a...) void( (SysLogLevel > 0) ? syslog(a) : void() )
#define isyslog(a...) void( (SysLogLevel > 1) ? syslog(a) : void() )
#define dsyslog(a...) void( (SysLogLevel > 2) ? syslog(a) : void() )
2000-12-08 16:23:32 +01:00
#define LOG_ERROR esyslog(LOG_ERR, "ERROR (%s,%d): %m", __FILE__, __LINE__)
#define LOG_ERROR_STR(s) esyslog(LOG_ERR, "ERROR: %s: %m", s)
2000-02-19 13:36:48 +01:00
#define SECSINDAY 86400
#define KILOBYTE(n) ((n) * 1024)
#define MEGABYTE(n) ((n) * 1024 * 1024)
#define MAXPARSEBUFFER KILOBYTE(10)
#define DELETENULL(p) (delete (p), p = NULL)
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; }
template<class T> inline void swap(T &a, T &b) { T t = a; a = b; b = t; }
2000-12-28 12:57:16 +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);
void writechar(int filedes, char c);
char *readline(FILE *f);
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);
char *strreplace(char *s, char c1, char c2);
2002-02-03 15:55:04 +01:00
char *strreplace(char *s, const char *s1, const char *s2); // re-allocates 's' and deletes the original string if necessary!
2000-10-29 13:17:22 +01:00
char *skipspace(const 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);
const char *strescape(const char *s, const char *chars); // returns a statically allocated string!
2001-08-17 13:19:10 +02:00
bool startswith(const char *s, const char *p);
bool endswith(const char *s, const char *p);
2000-10-29 13:17:22 +01:00
bool isempty(const char *s);
int time_ms(void);
void delay_ms(int ms);
2000-07-23 15:01:31 +02:00
bool isnumber(const char *s);
const char *AddDirectory(const char *DirName, const char *FileName); // returns a statically allocated string!
int FreeDiskSpaceMB(const char *Directory, int *UsedMB = NULL);
bool DirectoryOk(const char *DirName, bool LogErrors = false);
bool MakeDirs(const char *FileName, bool IsDirectory = false);
bool RemoveFileOrDir(const char *FileName, bool FollowSymlinks = false);
2001-02-11 14:53:44 +01:00
bool RemoveEmptyDirectories(const char *DirName, bool RemoveThis = false);
char *ReadLink(const char *FileName);
2001-08-11 11:15:41 +02:00
bool SpinUpDisk(const char *FileName);
const char *WeekDayName(int WeekDay); // returns a statically allocated string!
const char *DayDateTime(time_t t = 0); // returns a statically allocated string!
class cFile {
private:
static bool files[];
static int maxFiles;
int f;
public:
cFile(void);
~cFile();
operator int () { return f; }
bool Open(const char *FileName, int Flags, mode_t Mode = S_IRUSR | S_IWUSR | S_IRGRP);
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);
static bool FileReadyForWriting(int FileDes, int TimeoutMs = 1000);
};
class cSafeFile {
private:
FILE *f;
char *fileName;
char *tempName;
public:
cSafeFile(const char *FileName);
~cSafeFile();
operator FILE* () { return f; }
bool Open(void);
bool Close(void);
};
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();
2001-08-26 14:17:20 +02:00
virtual bool operator< (const cListObject &ListObject) { return false; }
2000-02-19 13:36:48 +01:00
void Append(cListObject *Object);
void Unlink(void);
int Index(void);
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);
public:
virtual ~cListBase();
void Add(cListObject *Object);
void Del(cListObject *Object);
virtual void Move(int From, int To);
void Move(cListObject *From, cListObject *To);
virtual void Clear(void);
2000-10-29 13:17:22 +01:00
cListObject *Get(int Index) const;
int Count(void) const;
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; }
T *Prev(const T *object) const { return (T *)object->Prev(); }
2000-10-29 13:17:22 +01:00
T *Next(const T *object) const { return (T *)object->Next(); }
2000-02-19 13:36:48 +01:00
};
#endif //__TOOLS_H