33#define MAXSYSLOGBUF 256
41 vsyslog(priority, fmt, ap);
53ssize_t
safe_read(
int filedes,
void *buffer,
size_t size)
56 ssize_t p = read(filedes, buffer, size);
57 if (p < 0 && errno == EINTR) {
58 dsyslog(
"EINTR while reading from file handle %d - retrying", filedes);
65ssize_t
safe_write(
int filedes,
const void *buffer,
size_t size)
68 ssize_t written = size;
69 const unsigned char *ptr = (
const unsigned char *)buffer;
71 p = write(filedes, ptr, size);
74 dsyslog(
"EINTR while writing to file handle %d - retrying", filedes);
82 return p < 0 ? p : written;
94 int w = write(fd, Data + written, Length);
103 Poller.
Poll(RetryMs);
104 if (TimeoutMs > 0 && (TimeoutMs -= t.
Elapsed()) <= 0)
117 int l =
max(dest ? strlen(dest) : 0, strlen(src)) + 1;
118 dest = (
char *)realloc(dest, l);
122 esyslog(
"ERROR: out of memory");
131char *
strn0cpy(
char *dest,
const char *src,
size_t n)
136 for ( ; --n && (*dest = *src) != 0; dest++, src++) ;
157 if (!s || !s1 || !*s1 || !s2 || strcmp(s1, s2) == 0)
160 if (
char *p = strstr(s, s1)) {
167 if (
char *NewBuffer = (
char *)realloc(s, l + l2 - l1 + 1))
170 esyslog(
"ERROR: out of memory");
176 memmove(sof + l2, sof + l1, l - of - l1 + 1);
181 }
while (p = strstr(q, s1));
186const char *
strchrn(
const char *s,
char c,
size_t n)
192 if (*s == c && --n == 0)
213 const char *p = strrchr(s, 0);
215 if (*p == c && --n == 0)
223 const char *p = strrchr(s, c);
224 return p ? p + 1 : s;
230 for (
char *p = s + strlen(s) - 1; p >= s; p--) {
247 memmove(p + 1, q, strlen(q) + 1);
251 memmove(s, t, strlen(t) + 1);
267 else if (t != s && n == 0) {
286 if (strchr(chars, *p)) {
288 buffer =
MALLOC(
char, 2 * strlen(s) + 1);
289 t = buffer + (p - s);
290 s = strcpy(buffer, s);
306 int l = strlen(name);
308 while (
const char *p = strstr(t, name)) {
310 if (p == s || *(p - 1) <=
' ') {
330 memmove(s, s + n, l - n + 1);
348 const char *se = s + strlen(s) - 1;
349 const char *pe = p + strlen(p) - 1;
351 if (*pe-- != *se-- || (se < s && pe >= p))
386 int64_t n = strtoll(s, &t, 10);
402 if (strcmp(*a, s) == 0)
412 if (*FileName ==
'/')
414 return cString::sprintf(
"%s/%s", DirName && *DirName ? DirName :
".", FileName);
417#define DECIMAL_POINT_C '.'
421 static lconv *loc = localeconv();
423 char buf[strlen(s) + 1];
427 *p = *loc->decimal_point;
442 static lconv *loc = localeconv();
444 snprintf(buf,
sizeof(buf), Format, d);
453 snprintf(buf,
sizeof(buf),
"%d", n);
460 if (stat(File1, &st) == 0) {
461 dev_t dev1 = st.st_dev;
462 if (stat(File2, &st) == 0)
463 return st.st_dev == dev1;
477 struct statfs statFs;
478 if (statfs(Directory, &statFs) == 0) {
479 double blocksPerMeg = 1024.0 * 1024.0 / statFs.f_bsize;
481 *UsedMB = int((statFs.f_blocks - statFs.f_bfree) / blocksPerMeg);
482 Free = int(statFs.f_bavail / blocksPerMeg);
492 if (stat(DirName, &ds) == 0) {
493 if (S_ISDIR(ds.st_mode)) {
494 if (access(DirName, R_OK | W_OK | X_OK) == 0)
497 esyslog(
"ERROR: can't access %s", DirName);
500 esyslog(
"ERROR: %s is not a directory", DirName);
507bool MakeDirs(
const char *FileName,
bool IsDirectory)
510 char *s = strdup(FileName);
514 while ((p = strchr(p,
'/')) != NULL || IsDirectory) {
518 if (stat(s, &fs) != 0 || !S_ISDIR(fs.st_mode)) {
519 dsyslog(
"creating directory %s", s);
520 if (mkdir(s, ACCESSPERMS) == -1) {
538 if (stat(FileName, &st) == 0) {
539 if (S_ISDIR(st.st_mode)) {
543 while ((e = d.
Next()) != NULL) {
545 if (FollowSymlinks) {
547 if (lstat(buffer, &st2) == 0) {
548 if (S_ISLNK(st2.st_mode)) {
549 int size = st2.st_size + 1;
550 char *l =
MALLOC(
char, size);
551 int n = readlink(buffer, l, size - 1);
565 else if (errno != ENOENT) {
570 dsyslog(
"removing %s", *buffer);
571 if (remove(buffer) < 0)
580 dsyslog(
"removing %s", FileName);
581 if (remove(FileName) < 0) {
586 else if (errno != ENOENT) {
595 bool HasIgnoredFiles =
false;
600 while ((e = d.
Next()) != NULL) {
601 if (strcmp(e->d_name,
"lost+found")) {
604 if (stat(buffer, &st) == 0) {
605 if (S_ISDIR(st.st_mode)) {
609 else if (RemoveThis && IgnoreFiles &&
StrInArray(IgnoreFiles, e->d_name))
610 HasIgnoredFiles =
true;
620 if (RemoveThis && empty) {
621 if (HasIgnoredFiles) {
622 while (*IgnoreFiles) {
624 if (access(buffer, F_OK) == 0) {
625 dsyslog(
"removing %s", *buffer);
626 if (remove(buffer) < 0) {
634 dsyslog(
"removing %s", DirName);
635 if (remove(DirName) < 0) {
653 while (size >= 0 && (e = d.
Next()) != NULL) {
656 if (stat(buffer, &st) == 0) {
657 if (S_ISDIR(st.st_mode)) {
674 else if (errno != ENOENT)
683 char *TargetName = canonicalize_file_name(FileName);
686 TargetName = strdup(FileName);
695 for (
int n = 0; n < 10; n++) {
701 if (access(buf, F_OK) != 0) {
703 gettimeofday(&tp1, NULL);
704 int f = open(buf, O_WRONLY | O_CREAT, DEFFILEMODE);
707 if (fdatasync(f) < 0)
711 gettimeofday(&tp2, NULL);
712 double seconds = (((
long long)tp2.tv_sec * 1000000 + tp2.tv_usec) - ((
long long)tp1.tv_sec * 1000000 + tp1.tv_usec)) / 1000000.0;
714 dsyslog(
"SpinUpDisk took %.2f seconds", seconds);
721 esyslog(
"ERROR: SpinUpDisk failed");
727 if (Create && access(FileName, F_OK) != 0) {
728 isyslog(
"creating file '%s'", FileName);
729 int f = open(FileName, O_WRONLY | O_CREAT, DEFFILEMODE);
735 if (utime(FileName, NULL) == -1 && errno != ENOENT)
742 if (stat(FileName, &fs) == 0)
750 if (stat(FileName, &fs) == 0)
767#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
768#define MIN_RESOLUTION 5
769 static bool initialized =
false;
770 static bool monotonic =
false;
774 if (clock_getres(CLOCK_MONOTONIC, &tp) == 0) {
775 long Resolution = tp.tv_nsec;
777 if (tp.tv_sec == 0 && tp.tv_nsec <= MIN_RESOLUTION * 1000000) {
778 if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
779 dsyslog(
"cTimeMs: using monotonic clock (resolution is %ld ns)", Resolution);
783 esyslog(
"cTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
786 dsyslog(
"cTimeMs: not using monotonic clock - resolution is too bad (%jd s %ld ns)", intmax_t(tp.tv_sec), tp.tv_nsec);
789 esyslog(
"cTimeMs: clock_getres(CLOCK_MONOTONIC) failed");
793 if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
794 return (uint64_t(tp.tv_sec)) * 1000 + tp.tv_nsec / 1000000;
795 esyslog(
"cTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
800# warning Posix monotonic clock not available
803 if (gettimeofday(&t, NULL) == 0)
804 return (uint64_t(t.tv_sec)) * 1000 + t.tv_usec / 1000;
831#define MT(s, m, v) ((*(s) & (m)) == (v))
832 if (
MT(s, 0xE0, 0xC0) &&
MT(s + 1, 0xC0, 0x80))
834 if (
MT(s, 0xF0, 0xE0) &&
MT(s + 1, 0xC0, 0x80) &&
MT(s + 2, 0xC0, 0x80))
836 if (
MT(s, 0xF8, 0xF0) &&
MT(s + 1, 0xC0, 0x80) &&
MT(s + 2, 0xC0, 0x80) &&
MT(s + 3, 0xC0, 0x80))
848 case 2:
return ((*s & 0x1F) << 6) | (*(s + 1) & 0x3F);
849 case 3:
return ((*s & 0x0F) << 12) | ((*(s + 1) & 0x3F) << 6) | (*(s + 2) & 0x3F);
850 case 4:
return ((*s & 0x07) << 18) | ((*(s + 1) & 0x3F) << 12) | ((*(s + 2) & 0x3F) << 6) | (*(s + 3) & 0x3F);
865 *s++ = ((c >> 6) & 0x1F) | 0xC0;
866 *s = (c & 0x3F) | 0x80;
872 *s++ = ((c >> 12) & 0x0F) | 0xE0;
873 *s++ = ((c >> 6) & 0x3F) | 0x80;
874 *s = (c & 0x3F) | 0x80;
880 *s++ = ((c >> 18) & 0x07) | 0xF0;
881 *s++ = ((c >> 12) & 0x3F) | 0x80;
882 *s++ = ((c >> 6) & 0x3F) | 0x80;
883 *s = (c & 0x3F) | 0x80;
895 while (*s && Symbols--) {
941 while (*s && --Size > 0) {
943 *a++ = (
uchar)(*s++);
960 while (*a && NumChars < Size) {
961 if (Max >= 0 && NumSyms++ >= Max)
969 if (NumChars + sl <= Size) {
994 cd = iconv_open(ToCode, FromCode);
1002 if (
cd != (iconv_t)-1)
1010 if (!strcasestr(CharacterTable,
"UTF-8")) {
1013 for (
int i = 0; i < 128; i++)
1017 const char *s = csc.
Convert(buf);
1031 if (
cd != (iconv_t)-1 && From && *From) {
1032 char *FromPtr = (
char *)From;
1033 size_t FromLength = strlen(From);
1036 int NewLength =
max(
length, FromLength * 2);
1037 if (
char *NewBuffer = (
char *)realloc(
result, NewLength)) {
1042 esyslog(
"ERROR: out of memory");
1051 char *Converted = ToPtr;
1052 while (FromLength > 0) {
1053 if (iconv(
cd, &FromPtr, &FromLength, &ToPtr, &ToLength) ==
size_t(-1)) {
1054 if (errno == E2BIG || errno == EILSEQ && ToLength < 1) {
1058 size_t d = ToPtr -
result;
1060 int NewLength =
length + r;
1061 if (
char *NewBuffer = (
char *)realloc(
result, NewLength)) {
1063 Converted =
result = NewBuffer;
1066 esyslog(
"ERROR: out of memory");
1072 if (errno == EILSEQ) {
1079 else if (errno != E2BIG)
1093 s = TakePointer ? (
char *)S : S ? strdup(S) : NULL;
1112 s = String.
s ? strdup(String.
s) : NULL;
1122 if (
this == &String)
1125 s = String.
s ? strdup(String.
s) : NULL;
1131 if (
this != &String) {
1144 s = String ? strdup(String) : NULL;
1151 int l1 =
s ? strlen(
s) : 0;
1152 int l2 = strlen(String);
1153 if (
char *p = (
char *)realloc(
s, l1 + l2 + 1)) {
1155 strcpy(
s + l1, String);
1158 esyslog(
"ERROR: out of memory");
1166 int l1 =
s ? strlen(
s) : 0;
1168 if (
char *p = (
char *)realloc(
s, l1 + l2 + 1)) {
1174 esyslog(
"ERROR: out of memory");
1184 if (Index >= 0 && Index < l)
1200 if (!fmt || vasprintf(&buffer, fmt, ap) < 0) {
1201 esyslog(
"error in vasprintf('%s', ...)", fmt);
1202 buffer = strdup(
"???");
1211 if (!fmt || vasprintf(&buffer, fmt, ap) < 0) {
1212 esyslog(
"error in vasprintf('%s', ...)", fmt);
1213 buffer = strdup(
"???");
1221 WeekDay = WeekDay == 0 ? 6 : WeekDay - 1;
1222 if (0 <= WeekDay && WeekDay <= 6) {
1224 const char *day =
tr(
"MonTueWedThuFriSatSun");
1236 return WeekDayName(localtime_r(&t, &tm_r)->tm_wday);
1241 WeekDay = WeekDay == 0 ? 6 : WeekDay - 1;
1243 case 0:
return tr(
"Monday");
1244 case 1:
return tr(
"Tuesday");
1245 case 2:
return tr(
"Wednesday");
1246 case 3:
return tr(
"Thursday");
1247 case 4:
return tr(
"Friday");
1248 case 5:
return tr(
"Saturday");
1249 case 6:
return tr(
"Sunday");
1250 default:
return "???";
1266 tm *tm = localtime_r(&t, &tm_r);
1267 snprintf(buffer,
sizeof(buffer),
"%s %02d.%02d. %02d:%02d", *
WeekDayName(tm->tm_wday), tm->tm_mday, tm->tm_mon + 1, tm->tm_hour, tm->tm_min);
1274 if (ctime_r(&t, buffer)) {
1275 buffer[strlen(buffer) - 1] = 0;
1285 tm *tm = localtime_r(&t, &tm_r);
1288 strftime(p,
sizeof(buf) - (p - buf),
"%d.%m.%Y", tm);
1296 tm *tm = localtime_r(&t, &tm_r);
1297 strftime(buf,
sizeof(buf),
"%d.%m.%y", tm);
1305 strftime(buf,
sizeof(buf),
"%R", localtime_r(&t, &tm_r));
1311#define JPEGCOMPRESSMEM 500000
1331 int Used = jcd->
size;
1333 if (
uchar *NewBuffer = (
uchar *)realloc(jcd->
mem, NewSize)) {
1334 jcd->
size = NewSize;
1335 jcd->
mem = NewBuffer;
1338 esyslog(
"ERROR: out of memory");
1342 cinfo->dest->next_output_byte = jcd->
mem + Used;
1343 cinfo->dest->free_in_buffer = jcd->
size - Used;
1354 int Used = cinfo->dest->next_output_byte - jcd->
mem;
1355 if (Used < jcd->size) {
1358 jcd->
mem = NewBuffer;
1361 esyslog(
"ERROR: out of memory");
1370 else if (Quality > 100)
1373 jpeg_destination_mgr jdm;
1379 struct jpeg_compress_struct cinfo;
1380 struct jpeg_error_mgr jerr;
1381 cinfo.err = jpeg_std_error(&jerr);
1382 jpeg_create_compress(&cinfo);
1385 cinfo.client_data = &jcd;
1386 cinfo.image_width = Width;
1387 cinfo.image_height = Height;
1388 cinfo.input_components = 3;
1389 cinfo.in_color_space = JCS_RGB;
1391 jpeg_set_defaults(&cinfo);
1392 jpeg_set_quality(&cinfo, Quality, TRUE);
1393 jpeg_start_compress(&cinfo, TRUE);
1396 JSAMPROW rp[Height];
1397 for (
int k = 0; k < Height; k++)
1398 rp[k] = &Mem[rs * k];
1399 jpeg_write_scanlines(&cinfo, rp, Height);
1400 jpeg_finish_compress(&cinfo);
1401 jpeg_destroy_compress(&cinfo);
1411 static char buffer[HOST_NAME_MAX] =
"";
1413 if (gethostname(buffer,
sizeof(buffer)) < 0) {
1415 strcpy(buffer,
"vdr");
1423const char *
cBase64Encoder::b64 =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1446 c |= (
data[
i] >> 4) & 0x0F;
1449 c = (
data[
i] << 2) & 0x3F;
1451 c |= (
data[
i] >> 6) & 0x03;
1550 Add(FileHandle, Out);
1555 if (FileHandle >= 0) {
1557 if (
pfd[i].fd == FileHandle &&
pfd[i].events == (Out ? POLLOUT : POLLIN))
1567 esyslog(
"ERROR: too many file handles in cPoller");
1574 if (FileHandle >= 0) {
1576 if (
pfd[i].fd == FileHandle &&
pfd[i].events == (Out ? POLLOUT : POLLIN)) {
1611#if !__GLIBC_PREREQ(2, 24)
1616 if (strcmp(
result->d_name,
".") && strcmp(
result->d_name,
".."))
1632 for (
int i = 0; i <
Size(); i++) {
1633 if (!strcmp(s,
At(i)))
1641 for (
int i = 0; i <
Size(); i++)
1651 Load(Directory, DirsOnly);
1661 while ((e =
d.Next()) != NULL) {
1664 if (stat(
AddDirectory(Directory, e->d_name), &ds) == 0) {
1665 if (!S_ISDIR(ds.st_mode))
1669 Append(strdup(e->d_name));
1695 return Open(open(FileName, Flags, Mode));
1696 esyslog(
"ERROR: attempt to re-open %s", FileName);
1706 esyslog(
"ERROR: attempt to re-open file descriptor %d", FileDes);
1727 struct timeval timeout;
1729 FD_SET(FileDes, &set);
1730 if (TimeoutMs >= 0) {
1731 if (TimeoutMs < 100)
1733 timeout.tv_sec = TimeoutMs / 1000;
1734 timeout.tv_usec = (TimeoutMs % 1000) * 1000;
1736 return select(FD_SETSIZE, &set, NULL, NULL, (TimeoutMs >= 0) ? &timeout : NULL) > 0 && FD_ISSET(FileDes, &set);
1773 if (ferror(
f) != 0) {
1779 if (fclose(
f) < 0) {
1796#ifndef USE_FADVISE_READ
1797#define USE_FADVISE_READ 0
1799#ifndef USE_FADVISE_WRITE
1800#define USE_FADVISE_WRITE 1
1803#define WRITE_BUFFER KILOBYTE(800)
1818 fd = open(FileName, Flags, Mode);
1820#if USE_FADVISE_READ || USE_FADVISE_WRITE
1828 posix_fadvise(
fd, 0, 0, POSIX_FADV_RANDOM);
1836#if USE_FADVISE_READ || USE_FADVISE_WRITE
1839 posix_fadvise(
fd, 0, 0, POSIX_FADV_DONTNEED);
1843 return close(OldFd);
1854#define FADVGRAN KILOBYTE(4)
1855#define READCHUNK MEGABYTE(8)
1865 return posix_fadvise(
fd, Offset - (
FADVGRAN - 1), Len + (
FADVGRAN - 1) * 2, POSIX_FADV_DONTNEED);
1870 if (Whence == SEEK_SET && Offset ==
curpos)
1872 curpos = lseek(
fd, Offset, Whence);
1890 if (bytesRead > 0) {
1897 if (jumped >= 0 && jumped <= (off_t)
readahead) {
1938#if USE_FADVISE_WRITE
1939 if (bytesWritten > 0) {
1980 return bytesWritten;
1988 if (File->
Open(FileName, Flags, Mode) < 0) {
1997#define LOCKFILENAME ".lock-vdr"
1998#define LOCKFILESTALETIME 600
2017 time_t Timeout = time(NULL) + WaitSeconds;
2019 f = open(
fileName, O_WRONLY | O_CREAT | O_EXCL, DEFFILEMODE);
2021 if (errno == EEXIST) {
2033 else if (errno != ENOENT) {
2040 if (errno == ENOSPC) {
2041 esyslog(
"ERROR: can't create lock file '%s' - assuming lock anyway!",
fileName);
2049 }
while (
f < 0 && time(NULL) < Timeout);
2077 Object->
prev =
this;
2083 Object->
next =
this;
2109#define LIST_GARBAGE_COLLECTOR_TIMEOUT 5
2122 esyslog(
"ERROR: ListGarbageCollector destroyed without prior Purge()!");
2169 return stateLock.Lock(StateKey, Write, TimeoutMs);
2171 esyslog(
"ERROR: cListBase::Lock() called for a list that doesn't require locking");
2193 if (Before && Before !=
objects) {
2230 if (From && To && From != To) {
2287 while (
object && Index-- > 0)
2288 object =
object->Next();
2307 while (
object && i < n) {
2309 object =
object->
Next();
2313 for (i = 0; i < n; i++) {
2337 if (
size < NewSize) {
2344 esyslog(
"ERROR: out of memory");
2376 unsigned int hash =
hashfn(Id);
2387 if (hob->object == Object) {
2397 for (
int i = 0; i <
size; i++) {
cBase64Encoder(const uchar *Data, int Length, int MaxResult=64)
Sets up a new base 64 encoder for the given Data, with the given Length.
const char * NextLine(void)
Returns the next line of encoded data (terminated by '\0'), or NULL if there is no more encoded data.
bool SetLength(int Length)
cCharSetConv(const char *FromCode=NULL, const char *ToCode=NULL)
Sets up a character set converter to convert from FromCode to ToCode.
static const char * SystemCharacterTable(void)
static void SetSystemCharacterTable(const char *CharacterTable)
static char * systemCharacterTable
const char * Convert(const char *From, char *To=NULL, size_t ToLength=0)
Converts the given Text from FromCode to ToCode (as set in the constructor).
static void SleepMs(int TimeoutMs)
Creates a cCondWait object and uses it to sleep for TimeoutMs milliseconds, immediately giving up the...
cDynamicBuffer(int InitialSize=1024)
bool Realloc(int NewSize)
void Append(const uchar *Data, int Length)
bool Load(const char *Directory, bool DirsOnly=false)
cFileNameList(const char *Directory=NULL, bool DirsOnly=false)
static bool FileReady(int FileDes, int TimeoutMs=1000)
bool Ready(bool Wait=true)
bool Open(const char *FileName, int Flags, mode_t Mode=DEFFILEMODE)
void Del(cListObject *Object, unsigned int Id)
cListObject * Get(unsigned int Id) const
cList< cHashObject > ** hashTable
cList< cHashObject > * GetList(unsigned int Id) const
cHashBase(int Size, bool OwnObjects)
Creates a new hash of the given Size.
void Add(cListObject *Object, unsigned int Id)
unsigned int hashfn(unsigned int Id) const
void Ins(cListObject *Object, cListObject *Before=NULL)
bool Contains(const cListObject *Object) const
If a pointer to an object contained in this list has been obtained while holding a lock,...
void Del(cListObject *Object, bool DeleteObject=true)
virtual void Move(int From, int To)
void SetExplicitModify(void)
If you have obtained a write lock on this list, and you don't want it to be automatically marked as m...
void SetModified(void)
Unconditionally marks this list as modified.
bool Lock(cStateKey &StateKey, bool Write=false, int TimeoutMs=0) const
Tries to get a lock on this list and returns true if successful.
const char * needsLocking
cListBase(const char *NeedsLocking=NULL)
const cListObject * Get(int Index) const
void Add(cListObject *Object, cListObject *After=NULL)
void Purge(bool Force=false)
cListGarbageCollector(void)
void Put(cListObject *Object)
cListObject(const cListObject &ListObject)
cListObject * Prev(void) const
virtual int Compare(const cListObject &ListObject) const
Must return 0 if this object is equal to ListObject, a positive value if it is "greater",...
void Insert(cListObject *Object)
cListObject * Next(void) const
void Append(cListObject *Object)
const T * First(void) const
Returns the first element in this list, or NULL if the list is empty.
const T * Next(const T *Object) const
< Returns the element immediately before Object in this list, or NULL if Object is the first element ...
bool Lock(int WaitSeconds=0)
cLockFile(const char *Directory)
cPoller(int FileHandle=-1, bool Out=false)
bool Add(int FileHandle, bool Out)
bool Poll(int TimeoutMs=0)
void Del(int FileHandle, bool Out)
cReadDir(const char *Directory)
struct dirent * Next(void)
union cReadDir::@177011034140060070152007220245225125302245142357 u
cSafeFile(const char *FileName)
void Sort(bool IgnoreCase=false)
virtual void Clear(void) override
int Find(const char *s) const
virtual ~cStringList() override
cString & CompactChars(char c)
Compact any sequence of characters 'c' to a single character, and strip all of them from the beginnin...
static cString static cString vsprintf(const char *fmt, va_list &ap)
cString(const char *S=NULL, bool TakePointer=false)
static cString sprintf(const char *fmt,...) __attribute__((format(printf
cString & operator=(const cString &String)
cString & Append(const char *String)
cString & Truncate(int Index)
Truncate the string at the given Index (if Index is < 0 it is counted from the end of the string).
static tThreadId ThreadId(void)
uint64_t Elapsed(void) const
void Set(int Ms=0)
Sets the timer.
bool TimedOut(void) const
cTimeMs(int Ms=0)
Creates a timer with ms resolution and an initial timeout of Ms.
static uint64_t Now(void)
static cUnbufferedFile * Create(const char *FileName, int Flags, mode_t Mode=DEFFILEMODE)
void SetReadAhead(size_t ra)
ssize_t Write(const void *Data, size_t Size)
int Open(const char *FileName, int Flags, mode_t Mode=DEFFILEMODE)
ssize_t Read(void *Data, size_t Size)
int FadviseDrop(off_t Offset, off_t Len)
off_t Seek(off_t Offset, int Whence)
virtual void Append(char *Data)
char *& At(int Index) const
static boolean JpegCompressEmptyOutputBuffer(j_compress_ptr cinfo)
static void JpegCompressInitDestination(j_compress_ptr cinfo)
static void JpegCompressTermDestination(j_compress_ptr cinfo)