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 .
*
2021-01-19 20:38:28 +01:00
* $ Id : tools . h 5.3 2021 / 01 / 19 20 : 38 : 28 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>
2010-12-24 11:34:11 +01:00
# include <stdarg.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>
2015-09-01 11:14:27 +02:00
# include "thread.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 ;
2013-08-23 10:37:54 +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_INFO, a) : void() )
# define dsyslog(a...) void( (SysLogLevel > 2) ? syslog_with_tid(LOG_DEBUG, 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__)
2011-12-04 14:48:53 +01:00
# define LOG_ERROR_STR(s) esyslog("ERROR (%s,%d): %s: %m", __FILE__, __LINE__, 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))
2013-02-17 13:19:36 +01:00
template < class T > inline void DELETENULL ( T * & p ) { T * q = p ; p = NULL ; delete q ; }
2000-03-11 11:22:37 +01:00
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
2017-06-11 10:05:34 +02:00
// In case some plugin needs to use the STL and gets an error message regarding one
// of these functions, you can #define DISABLE_TEMPLATES_COLLIDING_WITH_STL before
// including tools.h.
# if !defined(__STL_CONFIG_H) // for old versions of the STL
# if !defined(DISABLE_TEMPLATES_COLLIDING_WITH_STL) && !defined(_STL_ALGOBASE_H)
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 ; }
2017-05-22 20:21:30 +02:00
# endif
2002-09-08 11:46:53 +02:00
template < class T > inline int sgn ( T a ) { return a < 0 ? - 1 : a > 0 ? 1 : 0 ; }
2017-06-11 10:05:34 +02:00
# if !defined(DISABLE_TEMPLATES_COLLIDING_WITH_STL) && !defined(_MOVE_H)
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
2017-06-11 10:05:34 +02:00
# endif
2000-12-28 12:57:16 +01:00
2012-03-02 10:19:00 +01:00
template < class T > inline T constrain ( T v , T l , T h ) { return v < l ? l : v > h ? h : v ; }
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 ) ;
2013-08-21 11:02:52 +02:00
# define IsBitSet(v, b) ((v) & (1 << (b))) // checks if the bit at index b is set in v, where the least significant bit has index 0
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 ) ;
2011-12-04 13:40:52 +01:00
///< Copies at most n character bytes from Src to Dest, making sure that the
2007-06-16 10:41:21 +02:00
///< 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 ) ;
2013-10-10 13:13:30 +02:00
cString ( const char * S , const char * To ) ; ///< Copies S up to To (exclusive). To must be a valid pointer into S. If To is NULL, everything is copied.
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 ) ;
2015-05-22 13:44:43 +02:00
cString & Append ( 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).
2013-10-10 13:13:30 +02:00
cString & CompactChars ( char c ) ; ///< Compact any sequence of characters 'c' to a single character, and strip all of them from the beginning and end of this string.
2005-10-09 11:14:14 +02:00
static cString sprintf ( const char * fmt , . . . ) __attribute__ ( ( format ( printf , 1 , 2 ) ) ) ;
2012-05-08 11:23:56 +02:00
static cString vsprintf ( const char * fmt , va_list & ap ) ;
2004-12-26 12:45:22 +01:00
} ;
2020-12-26 15:49:01 +01:00
class cNullTerminate {
private :
char * p ;
char c ;
public :
cNullTerminate ( void ) {
p = NULL ;
c = 0 ;
}
cNullTerminate ( char * s ) {
Set ( s ) ;
}
~ cNullTerminate ( ) {
if ( p )
* p = c ;
}
void Set ( char * s ) {
if ( s ) {
p = s ;
c = * s ;
* s = 0 ;
}
else
p = NULL ;
}
} ;
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!
2013-10-10 13:13:30 +02:00
const char * strchrn ( const char * s , char c , size_t n ) ; ///< returns a pointer to the n'th occurrence (counting from 1) of c in s, or NULL if no such character was found. If n is 0, s is returned.
int strcountchr ( const char * s , char c ) ; ///< returns the number of occurrences of 'c' in 's'.
2021-01-19 20:38:28 +01:00
cString strgetbefore ( const char * s , char c , int n = 1 ) ; // returns the part of 's' before (and excluding) the n'th occurrence of 'c' from the right, or an empty string if there is no such 'c'.
2020-12-26 15:49:01 +01:00
const char * strgetlast ( const char * s , char c ) ; // returns the part of 's' after the last occurrence of 'c', or 's' if there is no 'c'.
2021-01-01 15:26:27 +01:00
inline char * strgetlast ( char * s , char c ) { return const_cast < char * > ( strgetlast ( static_cast < const char * > ( s ) , c ) ) ; } // returns the part of 's' after the last occurrence of 'c', or 's' if there is no 'c'.
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 ) ;
2013-10-10 13:13:30 +02:00
char * compactchars ( char * s , char c ) ; ///< removes all occurrences of 'c' from the beginning an end of 's' and replaces sequences of multiple 'c's with a single 'c'.
2004-12-26 12:45:22 +01:00
cString strescape ( const char * s , const char * chars ) ;
2015-05-22 13:44:43 +02:00
cString strgetval ( const char * s , const char * name , char d = ' = ' ) ;
///< Returns the value part of a 'name=value' pair in s.
///< name must either be at the beginning of s, or has to be preceded by white space.
///< There may be any number of white space around the '=' sign. The value is
2020-09-16 13:48:33 +02:00
///< everything up to (and excluding) the next white space, or the end of s.
2015-05-22 13:44:43 +02:00
///< If an other delimiter shall be used (like, e.g., ':'), it can be given
///< as the third parameter.
///< If name occurs more than once in s, only the first occurrence is taken.
2018-02-28 10:06:47 +01:00
char * strshift ( char * s , int n ) ;
///< Shifts the given string to the left by the given number of bytes, thus
///< removing the first n bytes from s.
///< If n is greater than the length of s, the resulting string will be empty.
///< If n is <= 0 s will be unchanged.
///< Returns s.
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 ) ;
2011-08-15 12:45:40 +02:00
int64_t StrToNum ( const char * s ) ;
///< Converts the given string to a number.
///< The numerical part of the string may be followed by one of the letters
///< K, M, G or T to abbreviate Kilo-, Mega-, Giga- or Terabyte, respectively
///< (based on 1024). Everything after the first non-numeric character is
2011-12-04 13:40:52 +01:00
///< silently ignored, as are any characters other than the ones mentioned here.
2012-09-30 13:05:14 +02:00
bool StrInArray ( const char * a [ ] , const char * s ) ;
///< Returns true if the string s is equal to one of the strings pointed
///< to by the (NULL terminated) array a.
2012-12-06 10:29:23 +01:00
double atod ( const char * s ) ;
///< Converts the given string, which is a floating point number using a '.' as
///< the decimal point, to a double value, independent of the currently selected
///< locale.
cString dtoa ( double d , const char * Format = " %f " ) ;
///< Converts the given double value to a string, making sure it uses a '.' as
///< the decimal point, independent of the currently selected locale.
///< If Format is given, it will be used instead of the default.
2004-12-26 12:45:22 +01:00
cString itoa ( int n ) ;
2017-03-18 16:33:59 +01:00
inline uint16_t Peek13 ( const uchar * p )
{
uint16_t v = uint16_t ( * p + + & 0x1F ) < < 8 ;
return v + ( * p & 0xFF ) ;
}
inline void Poke13 ( uchar * p , uint16_t v )
{
v | = uint16_t ( * p & ~ 0x1F ) < < 8 ;
* p + + = v > > 8 ;
* p = v & 0xFF ;
}
2004-12-26 12:45:22 +01:00
cString AddDirectory ( const char * DirName , const char * FileName ) ;
2008-02-16 13:38:22 +01:00
bool EntriesOnSameFileSystem ( const char * File1 , const char * File2 ) ;
2015-02-07 16:08:13 +01:00
///< Checks whether the given files are on the same file system. If either of the
///< files doesn't exist, this function returns *true* to avoid any actions that might be
///< triggered if files are on different file system.
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 ) ;
2012-09-30 13:05:14 +02:00
bool RemoveEmptyDirectories ( const char * DirName , bool RemoveThis = false , const char * IgnoreFiles [ ] = NULL ) ;
///< Removes all empty directories under the given directory DirName.
///< If RemoveThis is true, DirName will also be removed if it is empty.
///< IgnoreFiles can be set to an array of file names that will be ignored when
///< considering whether a directory is empty. If IgnoreFiles is given, the array
///< must end with a NULL pointer.
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 ) ;
2012-02-19 11:50:20 +01:00
off_t FileSize ( const char * FileName ) ; ///< returns the size of the given file, or -1 in case of an error (e.g. if the file doesn't exist)
2004-12-26 12:45:22 +01:00
cString WeekDayName ( int WeekDay ) ;
2012-04-01 11:36:10 +02:00
///< Converts the given WeekDay (0=Sunday, 1=Monday, ...) to a three letter
///< day name.
2004-12-26 12:45:22 +01:00
cString WeekDayName ( time_t t ) ;
2012-04-01 11:36:10 +02:00
///< Converts the week day of the given time to a three letter day name.
2007-06-23 13:40:04 +02:00
cString WeekDayNameFull ( int WeekDay ) ;
2012-04-01 11:36:10 +02:00
///< Converts the given WeekDay (0=Sunday, 1=Monday, ...) to a full
///< day name.
2007-06-23 13:40:04 +02:00
cString WeekDayNameFull ( time_t t ) ;
2012-04-01 11:36:10 +02:00
///< Converts the week day of the given time to a full day name.
2004-12-26 12:45:22 +01:00
cString DayDateTime ( time_t t = 0 ) ;
2012-04-01 11:36:10 +02:00
///< Converts the given time to a string of the form "www dd.mm. hh:mm".
///< If no time is given, the current time is taken.
2004-12-26 12:45:22 +01:00
cString TimeToString ( time_t t ) ;
2012-04-01 11:36:10 +02:00
///< Converts the given time to a string of the form "www mmm dd hh:mm:ss yyyy".
2005-05-16 14:45:11 +02:00
cString DateString ( time_t t ) ;
2012-04-01 11:36:10 +02:00
///< Converts the given time to a string of the form "www dd.mm.yyyy".
2012-05-12 14:20:41 +02:00
cString ShortDateString ( time_t t ) ;
///< Converts the given time to a string of the form "dd.mm.yy".
2005-05-16 14:45:11 +02:00
cString TimeString ( time_t t ) ;
2012-04-01 11:36:10 +02:00
///< Converts the given time to a string of the form "hh:mm".
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.
2015-09-08 11:08:06 +02:00
const char * GetHostName ( void ) ;
///< Gets the host name of this machine.
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
} ;
2011-09-18 11:36:38 +02:00
class cBitStream {
private :
const uint8_t * data ;
int length ; // in bits
int index ; // in bits
public :
cBitStream ( const uint8_t * Data , int Length ) : data ( Data ) , length ( Length ) , index ( 0 ) { }
~ cBitStream ( ) { }
int GetBit ( void ) ;
uint32_t GetBits ( int n ) ;
void ByteAlign ( void ) ;
void WordAlign ( void ) ;
bool SetLength ( int Length ) ;
void SkipBits ( int n ) { index + = n ; }
void SkipBit ( void ) { SkipBits ( 1 ) ; }
bool IsEOF ( void ) const { return index > = length ; }
void Reset ( void ) { index = 0 ; }
int Length ( void ) const { return length ; }
int Index ( void ) const { return ( IsEOF ( ) ? length : index ) ; }
const uint8_t * GetData ( void ) const { return ( IsEOF ( ) ? NULL : data + ( index / 8 ) ) ; }
} ;
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.
2011-08-15 14:13:42 +02:00
///< If Ms is negative the timer is not initialized with the current
///< time.
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 ) ;
2020-06-23 15:52:29 +02:00
///< Sets the timer. If Ms is 0, call Elapsed() to get the number of milliseconds
///< since the timer has been set. If Ms is greater than 0, TimedOut() returns
///< true as soon as Ms milliseconds have passed since calling Set(). If Ms is
///< negative, results are undefined.
///< Depending on the value of Ms, an object of cTimeMs can handle either
///< timeouts or elapsed times, not both at the same time.
2013-08-21 11:02:52 +02:00
bool TimedOut ( void ) const ;
uint64_t Elapsed ( void ) const ;
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 :
2015-05-22 13:44:43 +02:00
enum { MaxPollFiles = 64 } ;
2002-08-16 09:22:29 +02:00
pollfd pfd [ MaxPollFiles ] ;
int numFileHandles ;
public :
cPoller ( int FileHandle = - 1 , bool Out = false ) ;
bool Add ( int FileHandle , bool Out ) ;
2015-05-22 13:44:43 +02:00
void Del ( int FileHandle , bool Out ) ;
2002-08-16 09:22:29 +02:00
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 ;
2017-06-25 11:54:32 +02:00
# if !__GLIBC_PREREQ(2, 24) // readdir_r() is deprecated as of GLIBC 2.24
2004-12-19 16:33:34 +01:00
union { // according to "The GNU C Library Reference Manual"
struct dirent d ;
char b [ offsetof ( struct dirent , d_name ) + NAME_MAX + 1 ] ;
} u ;
2017-06-25 11:54:32 +02:00
# endif
2004-12-19 16:33:34 +01:00
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 {
2015-09-01 11:14:27 +02:00
friend class cListGarbageCollector ;
2000-02-19 13:36:48 +01:00
private :
cListObject * prev , * next ;
2017-05-09 08:39:19 +02:00
cListObject ( const cListObject & ListObject ) { abort ( ) ; } // no copy constructor!
cListObject & operator = ( const cListObject & ListObject ) { abort ( ) ; return * this ; } // no assignment operator!
2000-02-19 13:36:48 +01:00
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
} ;
2015-09-01 11:14:27 +02:00
class cListGarbageCollector {
private :
cMutex mutex ;
cListObject * objects ;
time_t lastPut ;
public :
cListGarbageCollector ( void ) ;
~ cListGarbageCollector ( ) ;
void Put ( cListObject * Object ) ;
void Purge ( bool Force = false ) ;
} ;
extern cListGarbageCollector ListGarbageCollector ;
2000-02-19 13:36:48 +01:00
class cListBase {
protected :
cListObject * objects , * lastObject ;
2005-05-26 11:41:33 +02:00
int count ;
2015-09-01 11:14:27 +02:00
mutable cStateLock stateLock ;
const char * needsLocking ;
bool useGarbageCollector ;
cListBase ( const char * NeedsLocking = NULL ) ;
2000-02-19 13:36:48 +01:00
public :
virtual ~ cListBase ( ) ;
2015-09-01 11:14:27 +02:00
bool Lock ( cStateKey & StateKey , bool Write = false , int TimeoutMs = 0 ) const ;
///< Tries to get a lock on this list and returns true if successful.
///< By default a read lock is requested. Set Write to true to obtain
///< a write lock. If TimeoutMs is not zero, it waits for the given
///< number of milliseconds before giving up.
///< If you need to lock more than one list at the same time, make sure
///< you set TimeoutMs to a suitable value in all of the calls to
///< Lock(), and be prepared to handle situations where you do not get all
///< of the requested locks. In such cases you should release all the locks
///< you have obtained so far and try again. StateKey.TimedOut() tells you
///< whether the lock attempt failed due to a timeout or because the state
///< of the lock hasn't changed since the previous locking attempt.
///< To implicitly avoid deadlocks when locking more than one of the global
///< lists of VDR at the same time, make sure you always lock Timers, Channels,
///< Recordings and Schedules in this sequence.
///< You may keep pointers to objects in this list, even after releasing
///< the lock. However, you may only access such objects if you are
///< holding a proper lock again. If an object has been deleted from the list
///< while you did not hold a lock (for instance by an other thread), the
///< object will still be there, but no longer within this list (it is then
///< stored in the ListGarbageCollector). That way even if you access the object
///< after it has been deleted, you won't cause a segfault. You can call the
///< Contains() function to check whether an object you are holding a pointer
///< to is still in the list. Note that the garbage collector is purged when
///< the usual housekeeping is done.
2018-03-04 14:15:07 +01:00
void SetSyncStateKey ( cStateKey & StateKey ) { stateLock . SetSyncStateKey ( StateKey ) ; }
///< When making changes to this list (while holding a write lock) that shall
///< not affect some other code that reacts to such changes, this function can
///< be called with the StateKey used by that other code.
///< See cStateLock::SetSyncStateKey() for details.
2015-09-01 11:14:27 +02:00
void SetUseGarbageCollector ( void ) { useGarbageCollector = true ; }
void SetExplicitModify ( void ) ;
///< If you have obtained a write lock on this list, and you don't want it to
///< be automatically marked as modified when the lock is released, a call to
///< this function will disable this, and you can explicitly call SetModified()
///< to have the list marked as modified.
void SetModified ( void ) ;
///< Unconditionally marks this list as modified.
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 ) ;
2015-09-01 11:14:27 +02:00
bool Contains ( const cListObject * Object ) const ;
///< If a pointer to an object contained in this list has been obtained while
///< holding a lock, and that lock has been released, but the pointer is kept for
///< later use (after obtaining a new lock), Contains() can be called with that
///< pointer to make sure the object it points to is still part of this list
///< (it may have been deleted or otherwise removed from the list after the lock
///< during which the pointer was initially retrieved has been released).
const cListObject * Get ( int Index ) const ;
cListObject * Get ( int Index ) { return const_cast < cListObject * > ( static_cast < const cListBase * > ( this ) - > Get ( Index ) ) ; }
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 :
2015-09-01 11:14:27 +02:00
cList ( const char * NeedsLocking = NULL ) : cListBase ( NeedsLocking ) { }
///< Sets up a new cList of the given type T. If NeedsLocking is given, the list
///< and any of its elements may only be accessed if the caller holds a lock
///< obtained by a call to Lock() (see cListBase::Lock() for details).
///< NeedsLocking is used as both a boolean flag to enable locking, and as
///< a name to identify this list in debug output. It must be a static string
///< and should be no longer than 10 characters. The string will not be copied!
const T * Get ( int Index ) const { return ( T * ) cListBase : : Get ( Index ) ; }
///< Returns the list element at the given Index, or NULL if no such element
///< exists.
const T * First ( void ) const { return ( T * ) objects ; }
///< Returns the first element in this list, or NULL if the list is empty.
const T * Last ( void ) const { return ( T * ) lastObject ; }
///< Returns the last element in this list, or NULL if the list is empty.
const T * Prev ( const T * Object ) const { return ( T * ) Object - > cListObject : : Prev ( ) ; } // need to call cListObject's members to
///< Returns the element immediately before Object in this list, or NULL
///< if Object is the first element in the list. Object must not be NULL!
const T * Next ( const T * Object ) const { return ( T * ) Object - > cListObject : : Next ( ) ; } // avoid ambiguities in case of a "list of lists"
///< Returns the element immediately following Object in this list, or NULL
///< if Object is the last element in the list. Object must not be NULL!
T * Get ( int Index ) { return const_cast < T * > ( static_cast < const cList < T > * > ( this ) - > Get ( Index ) ) ; }
///< Non-const version of Get().
T * First ( void ) { return const_cast < T * > ( static_cast < const cList < T > * > ( this ) - > First ( ) ) ; }
///< Non-const version of First().
T * Last ( void ) { return const_cast < T * > ( static_cast < const cList < T > * > ( this ) - > Last ( ) ) ; }
///< Non-const version of Last().
T * Prev ( const T * Object ) { return const_cast < T * > ( static_cast < const cList < T > * > ( this ) - > Prev ( Object ) ) ; }
///< Non-const version of Prev().
T * Next ( const T * Object ) { return const_cast < T * > ( static_cast < const cList < T > * > ( this ) - > Next ( Object ) ) ; }
///< Non-const version of Next().
2000-02-19 13:36:48 +01:00
} ;
2015-09-01 11:14:27 +02:00
// The DEF_LIST_LOCK macro defines a convenience class that can be used to obtain
// a lock on a cList and make sure the lock is released when the current scope
// is left:
# define DEF_LIST_LOCK2(Class, Name) \
2017-06-11 09:01:47 +02:00
class c # # Name # # _Lock { \
2015-09-01 11:14:27 +02:00
private : \
cStateKey stateKey ; \
const c # # Class * list ; \
public : \
2017-06-11 09:01:47 +02:00
c # # Name # # _Lock ( bool Write = false ) \
2015-09-01 11:14:27 +02:00
{ \
if ( Write ) \
list = c # # Class : : Get # # Name # # Write ( stateKey ) ; \
else \
list = c # # Class : : Get # # Name # # Read ( stateKey ) ; \
} \
2017-06-11 09:01:47 +02:00
~ c # # Name # # _Lock ( ) { if ( list ) stateKey . Remove ( ) ; } \
2015-09-01 11:14:27 +02:00
const c # # Class * Name ( void ) const { return list ; } \
c # # Class * Name ( void ) { return const_cast < c # # Class * > ( list ) ; } \
}
# define DEF_LIST_LOCK(Class) DEF_LIST_LOCK2(Class, Class)
// The USE_LIST_LOCK macro sets up a local variable of a class defined by
// a suitable DEF_LIST_LOCK, and also a pointer to the provided list:
# define USE_LIST_LOCK_READ2(Class, Name) \
2017-06-11 09:01:47 +02:00
c # # Name # # _Lock Name # # _Lock ( false ) ; \
const c # # Class * Name __attribute__ ( ( unused ) ) = Name # # _Lock . Name ( ) ;
2015-09-01 11:14:27 +02:00
# define USE_LIST_LOCK_READ(Class) USE_LIST_LOCK_READ2(Class, Class)
# define USE_LIST_LOCK_WRITE2(Class, Name) \
2017-06-11 09:01:47 +02:00
c # # Name # # _Lock Name # # _Lock ( true ) ; \
c # # Class * Name __attribute__ ( ( unused ) ) = Name # # _Lock . Name ( ) ;
2015-09-01 11:14:27 +02:00
# define USE_LIST_LOCK_WRITE(Class) USE_LIST_LOCK_WRITE2(Class, Class)
2007-06-10 13:02:43 +02:00
template < class T > class cVector {
2012-05-19 12:32:32 +02:00
///< cVector may only be used for *simple* types, like int or pointers - not for class objects that allocate additional memory!
2007-06-10 13:02:43 +02:00
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 ) ) ;
2011-02-25 15:25:42 +01:00
if ( ! data ) {
esyslog ( " ERROR: out of memory - abort! " ) ;
abort ( ) ;
}
2007-06-17 11:12:46 +02:00
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 ) ;
}
2015-01-12 12:10:15 +01:00
int IndexOf ( const T & Data ) // returns the index of Data, or -1 if not found
{
for ( int i = 0 ; i < size ; i + + ) {
if ( data [ i ] = = Data )
return i ;
}
return - 1 ;
}
2007-06-10 13:02:43 +02:00
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 ) ;
}
2015-01-14 09:09:06 +01:00
bool InsertUnique ( T Data , int Before = 0 )
2015-01-12 12:10:15 +01:00
{
2015-01-14 09:09:06 +01:00
if ( IndexOf ( Data ) < 0 ) {
2015-01-12 12:10:15 +01:00
Insert ( Data , Before ) ;
2015-01-14 09:09:06 +01:00
return true ;
}
return false ;
2015-01-12 12:10:15 +01:00
}
2007-06-10 13:02:43 +02:00
virtual void Append ( T Data )
{
if ( size > = allocated )
2012-05-19 12:32:32 +02:00
Realloc ( allocated * 3 / 2 ) ; // increase size by 50%
2007-06-10 13:02:43 +02:00
data [ size + + ] = Data ;
}
2015-01-14 09:09:06 +01:00
bool AppendUnique ( T Data )
2015-01-12 12:10:15 +01:00
{
2015-01-14 09:09:06 +01:00
if ( IndexOf ( Data ) < 0 ) {
2015-01-12 12:10:15 +01:00
Append ( Data ) ;
2015-01-14 09:09:06 +01:00
return true ;
}
return false ;
2015-01-12 12:10:15 +01:00
}
2007-08-26 09:58:10 +02:00
virtual void Remove ( int Index )
{
2015-01-12 12:14:16 +01:00
if ( Index < 0 )
return ; // prevents out-of-bounds access
2007-08-26 09:58:10 +02:00
if ( Index < size - 1 )
memmove ( & data [ Index ] , & data [ Index + 1 ] , ( size - Index ) * sizeof ( T ) ) ;
size - - ;
}
2015-01-14 09:09:06 +01:00
bool RemoveElement ( const T & Data )
2015-01-12 12:10:15 +01:00
{
int i = IndexOf ( Data ) ;
2015-01-14 09:09:06 +01:00
if ( i > = 0 ) {
2015-01-12 12:10:15 +01:00
Remove ( i ) ;
2015-01-14 09:09:06 +01:00
return true ;
}
return false ;
2015-01-12 12:10:15 +01:00
}
2008-01-01 15:10:07 +01:00
virtual void Clear ( void )
{
2012-05-20 14:01:02 +02:00
for ( int i = 0 ; i < size ; i + + )
data [ i ] = T ( 0 ) ;
2008-01-01 15:10:07 +01:00
size = 0 ;
}
2007-06-10 13:02:43 +02:00
void Sort ( __compar_fn_t Compare )
{
qsort ( data , size , sizeof ( T ) , Compare ) ;
}
} ;
2017-03-18 16:33:59 +01:00
inline int CompareInts ( const void * a , const void * b )
{
2018-02-28 10:14:18 +01:00
return * ( const int * ) a - * ( const int * ) b ;
2017-03-18 16:33:59 +01:00
}
2007-06-10 13:02:43 +02:00
inline int CompareStrings ( const void * a , const void * b )
{
return strcmp ( * ( const char * * ) a , * ( const char * * ) b ) ;
}
2011-08-12 14:05:56 +02:00
inline int CompareStringsIgnoreCase ( const void * a , const void * b )
{
return strcasecmp ( * ( const char * * ) a , * ( const char * * ) b ) ;
}
2018-02-28 10:06:47 +01:00
inline int CompareStringsNumerically ( const void * a , const void * b )
{
int d = atoi ( * ( const char * * ) a ) - atoi ( * ( const char * * ) b ) ;
return d ? d : CompareStrings ( a , 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 ;
2011-08-12 14:05:56 +02:00
void Sort ( bool IgnoreCase = false )
{
if ( IgnoreCase )
cVector < char * > : : Sort ( CompareStringsIgnoreCase ) ;
else
cVector < char * > : : Sort ( CompareStrings ) ;
}
2018-02-28 10:06:47 +01:00
void SortNumerically ( void )
{
cVector < char * > : : Sort ( CompareStringsNumerically ) ;
}
2007-06-17 11:12:46 +02:00
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
} ;
2016-12-23 14:08:14 +01:00
class cDynamicBuffer {
private :
uchar * buffer ;
int initialSize ;
int size ; // the total size of the buffer (bytes in memory)
int used ; // the number of used bytes, starting at the beginning of the buffer
bool Realloc ( int NewSize ) ;
bool Assert ( int NewSize ) { return size < NewSize ? Realloc ( NewSize ) : true ; } // inline for performance!
public :
cDynamicBuffer ( int InitialSize = 1024 ) ;
~ cDynamicBuffer ( ) ;
void Append ( const uchar * Data , int Length ) ;
void Append ( uchar Data ) { if ( Assert ( used + 1 ) ) buffer [ used + + ] = Data ; }
void Set ( int Index , uchar Data ) { if ( Assert ( Index + 1 ) ) buffer [ Index ] = Data ; }
uchar Get ( int Index ) { return Index < used ? buffer [ Index ] : 0 ; }
void Clear ( void ) { used = 0 ; }
uchar * Data ( void ) { return buffer ; }
int Length ( void ) { return used ; }
} ;
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 ;
2017-05-09 08:33:37 +02:00
bool ownObjects ;
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 :
2017-05-09 08:33:37 +02:00
cHashBase ( int Size , bool OwnObjects ) ;
///< Creates a new hash of the given Size. If OwnObjects is true, the
///< hash takes ownership of the objects given in the calls to Add(),
///< and deletes them when Clear() is called or the hash is destroyed
///< (unless the object has been removed from the hash by calling Del()).
2005-05-28 13:17:20 +02:00
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 :
2017-05-09 08:33:37 +02:00
cHash ( int Size = HASHSIZE , bool OwnObjects = false ) : cHashBase ( Size , OwnObjects ) { }
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