From f7e5ac3208a40ceed8bc3bd05fe81bffc774bbf5 Mon Sep 17 00:00:00 2001 From: kamel5 Date: Fri, 22 Mar 2019 13:21:18 +0100 Subject: [PATCH] Some cosmetic changes --- switchtimer.c | 12 -- switchtimer.h | 10 +- timerconflict.c | 20 +-- tools.c | 426 ++++++++++++++++++++++++------------------------ tools.h | 28 ++-- 5 files changed, 243 insertions(+), 253 deletions(-) diff --git a/switchtimer.c b/switchtimer.c index 125b11e..3a45f79 100644 --- a/switchtimer.c +++ b/switchtimer.c @@ -22,18 +22,6 @@ cSwitchTimer::cSwitchTimer(const cEvent* Event) { } } -#if VDRVERSNUM >= 20305 -cSwitchTimer& cSwitchTimer::operator= (const cSwitchTimer &SwitchTimer) -{ - this->eventID = SwitchTimer.eventID; - this->startTime = SwitchTimer.startTime; - this->channelID = SwitchTimer.channelID; - this->switchMinsBefore = SwitchTimer.switchMinsBefore; - this->announceOnly = SwitchTimer.announceOnly; - return *this; -} - -#endif bool cSwitchTimer::Parse(const char *s) { char *line; char *pos; diff --git a/switchtimer.h b/switchtimer.h index 867a821..b661fdd 100644 --- a/switchtimer.h +++ b/switchtimer.h @@ -12,7 +12,15 @@ public: int announceOnly; #if VDRVERSNUM >= 20305 cSwitchTimer(const cSwitchTimer &SwitchTimer) { *this = SwitchTimer; }; - cSwitchTimer& operator= (const cSwitchTimer &SwitchTimer); + cSwitchTimer& operator= (const cSwitchTimer &SwitchTimer) + { + this->eventID = SwitchTimer.eventID; + this->startTime = SwitchTimer.startTime; + this->channelID = SwitchTimer.channelID; + this->switchMinsBefore = SwitchTimer.switchMinsBefore; + this->announceOnly = SwitchTimer.announceOnly; + return *this; + }; #endif cSwitchTimer(void); cSwitchTimer(const cEvent* Event); diff --git a/timerconflict.c b/timerconflict.c index 6f34842..e57d6ff 100644 --- a/timerconflict.c +++ b/timerconflict.c @@ -71,7 +71,7 @@ void cTVGuideTimerConflicts::AddConflict(std::string epgSearchConflictLine) { splitstring s3(flds2[2].c_str()); std::vector flds3 = s3.split('#'); std::vector timerIDs; - for (int k = 0; k < flds3.size(); k++) { + for (int k = 0; k < (int)flds3.size(); k++) { timerIDs.push_back(atoi(flds3[k].c_str()) - 1); } conflict->timerIDs = timerIDs; @@ -80,18 +80,17 @@ void cTVGuideTimerConflicts::AddConflict(std::string epgSearchConflictLine) { void cTVGuideTimerConflicts::CalculateConflicts(void) { numConflicts = conflicts.size(); -// time_t startTime = 0; -// time_t endTime = 0; for (int i=0; i < numConflicts; i++) { cTimeInterval *unionSet = NULL; int numTimers = conflicts[i]->timerIDs.size(); - for (int j=0; j < numTimers; j++) { #if VDRVERSNUM >= 20301 - LOCK_TIMERS_READ; - const cTimer *timer = Timers->Get(conflicts[i]->timerIDs[j]); + LOCK_TIMERS_READ; + const cTimers* timers = Timers; #else - const cTimer *timer = Timers.Get(conflicts[i]->timerIDs[j]); + const cTimers* timers = &Timers; #endif + for (int j=0; j < numTimers; j++) { + const cTimer *timer = timers->Get(conflicts[i]->timerIDs[j]); if (timer) { if (!unionSet) { unionSet = new cTimeInterval(timer->StartTime(), timer->StopTime()); @@ -110,12 +109,7 @@ void cTVGuideTimerConflicts::CalculateConflicts(void) { cTimeInterval *intersect = NULL; for (int j=0; j < numTimers; j++) { -#if VDRVERSNUM >= 20301 - LOCK_TIMERS_READ; - const cTimer *timer = Timers->Get(conflicts[i]->timerIDs[j]); -#else - const cTimer *timer = Timers.Get(conflicts[i]->timerIDs[j]); -#endif + const cTimer *timer = timers->Get(conflicts[i]->timerIDs[j]); if (timer) { if (!intersect) { intersect = new cTimeInterval(timer->StartTime(), timer->StopTime()); diff --git a/tools.c b/tools.c index b069bd0..075c0ce 100644 --- a/tools.c +++ b/tools.c @@ -144,7 +144,7 @@ std::vector& splitstring::split(char delim, int rep) { std::string work = data(); std::string buf = ""; int i = 0; - while (i < work.length()) { + while (i < (int)work.length()) { if (work[i] != delim) buf += work[i]; else if (rep == 1) { @@ -179,61 +179,61 @@ int FindIgnoreCase(const std::string& expr, const std::string& query) * GetAuxValue ****************************************************************************************/ char* GetAuxValue(const char* aux, const char* name) { - if (isempty(aux)) - return NULL; - - char* descr = strdup(aux); - char* beginaux = strstr(descr, ""); - char* endaux = strstr(descr, ""); - if (!beginaux || !endaux) { + if (isempty(aux)) + return NULL; + + char* descr = strdup(aux); + char* beginaux = strstr(descr, ""); + char* endaux = strstr(descr, ""); + if (!beginaux || !endaux) { free(descr); - return NULL; - } + return NULL; + } - beginaux += 11; // strlen(""); - endaux[0] = 0; - memmove(descr, beginaux, endaux - beginaux + 1); + beginaux += 11; // strlen(""); + endaux[0] = 0; + memmove(descr, beginaux, endaux - beginaux + 1); - if (strcmp(name, "epgsearch") == 0) - return descr; // full aux + if (strcmp(name, "epgsearch") == 0) + return descr; // full aux - int namelen = strlen(name); - char catname[100] = ""; - catname[0] = '<'; - memcpy(catname + 1, name, namelen); - catname[1 + namelen] = '>'; - catname[2 + namelen] = 0; + int namelen = strlen(name); + char catname[100] = ""; + catname[0] = '<'; + memcpy(catname + 1, name, namelen); + catname[1 + namelen] = '>'; + catname[2 + namelen] = 0; - char* cat = strcasestr(descr, catname); - if (!cat) { - free(descr); - return NULL; + char* cat = strcasestr(descr, catname); + if (!cat) { + free(descr); + return NULL; } - cat += namelen + 2; - char* end = strstr(cat, "Info()) + if (!recording || !recording->Info()) return NULL; return GetAuxValue(recording->Info()->Aux(), name); } char* GetAuxValue(const cTimer *timer, const char* name) { - if (!timer || !timer->Aux()) + if (!timer || !timer->Aux()) return NULL; return GetAuxValue(timer->Aux(), name); } @@ -244,239 +244,239 @@ char* GetAuxValue(const cTimer *timer, const char* name) { /****************************************************************************** FUNCTION afuzzy_init() - Initialization of the fuzzy search routine. This applies to the consequent - calls of the afuzzy_CheckRTR (whole string matching) and afuzzy_CheckSUB - (substring match) routines. afuzzy_init() should be called for each - new pattern or error length. The search is case sensitive + Initialization of the fuzzy search routine. This applies to the consequent + calls of the afuzzy_CheckRTR (whole string matching) and afuzzy_CheckSUB + (substring match) routines. afuzzy_init() should be called for each + new pattern or error length. The search is case sensitive ARGUMENTS: - p Pattern - kerr Number of possible errors. Shouldn't exceed pattern length - UseFilter Use agrep filter algorithm that speeds up search. - fuzzy pointer to the structure that will be later passes to Check* - (the first 6 elements should be NULLs for the first call) - + p Pattern + kerr Number of possible errors. Shouldn't exceed pattern length + UseFilter Use agrep filter algorithm that speeds up search. + fuzzy pointer to the structure that will be later passes to Check* + (the first 6 elements should be NULLs for the first call) + RETURN VALUE: - none + none ALGORITHM - see. the article on agrep algorithms. - The only change is accounting transpositions as one edit operation . + see. the article on agrep algorithms. + The only change is accounting transpositions as one edit operation . ******************************************************************************/ void afuzzy_init(const char *p, int kerr, int UseFilter, AFUZZY *fuzzy) { - int cnt, p_len, i, j, l, d, m, dd; - char PatFilter[sizeof(Uint)*8 + 1]; + int cnt, p_len, i, j, l, d, m, dd; + char PatFilter[sizeof(Uint)*8 + 1]; - fuzzy->k = kerr; - m = strlen(p); - fuzzy->FilterSet = 0; - memset(fuzzy->Map, 0 , sizeof(fuzzy->Map) ); + fuzzy->k = kerr; + m = strlen(p); + fuzzy->FilterSet = 0; + memset(fuzzy->Map, 0 , sizeof(fuzzy->Map) ); - if (fuzzy->S) - free(fuzzy->S); - if (fuzzy->R) - free(fuzzy->R); - if (fuzzy->R1) - free(fuzzy->R1); - if (fuzzy->RP) - free(fuzzy->RP); - if (fuzzy->RI) - free(fuzzy->RI); - if (fuzzy->FilterS) - free(fuzzy->FilterS); + if (fuzzy->S) + free(fuzzy->S); + if (fuzzy->R) + free(fuzzy->R); + if (fuzzy->R1) + free(fuzzy->R1); + if (fuzzy->RP) + free(fuzzy->RP); + if (fuzzy->RI) + free(fuzzy->RI); + if (fuzzy->FilterS) + free(fuzzy->FilterS); - fuzzy->FilterS = NULL; - fuzzy->S = (Uint *)calloc(m + 1, sizeof(Uint)); - fuzzy->R = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint)); - fuzzy->R1 = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint)); - fuzzy->RI = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint)); - fuzzy->RP = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint)); + fuzzy->FilterS = NULL; + fuzzy->S = (Uint *)calloc(m + 1, sizeof(Uint)); + fuzzy->R = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint)); + fuzzy->R1 = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint)); + fuzzy->RI = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint)); + fuzzy->RP = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint)); - for (i = 0, cnt = 0; i < m; i++) - { - l = fuzzy->Map[(unsigned char)p[i]]; - if (!l) - { - l = fuzzy->Map[(unsigned char)p[i]] = ++cnt; - fuzzy->S[l] = 0; - } - fuzzy->S[l] |= 1 << i; - } + for (i = 0, cnt = 0; i < m; i++) + { + l = fuzzy->Map[(unsigned char)p[i]]; + if (!l) + { + l = fuzzy->Map[(unsigned char)p[i]] = ++cnt; + fuzzy->S[l] = 0; + } + fuzzy->S[l] |= 1 << i; + } - for (d = 0; d <= fuzzy->k; d++) - fuzzy->RI[d] = (1 << d) - 1; + for (d = 0; d <= fuzzy->k; d++) + fuzzy->RI[d] = (1 << d) - 1; - fuzzy->mask_ok = (1 << (m - 1)); - fuzzy->r_size = sizeof(Uint) * (fuzzy->k + 1); - p_len = m; + fuzzy->mask_ok = (1 << (m - 1)); + fuzzy->r_size = sizeof(Uint) * (fuzzy->k + 1); + p_len = m; - if (p_len > (int) sizeof(Uint)*8) - p_len = (int) sizeof(Uint)*8; + if (p_len > (int) sizeof(Uint)*8) + p_len = (int) sizeof(Uint)*8; - /* If k is zero then no filter is needed! */ - if (fuzzy->k && (p_len >= 2*(fuzzy->k + 1)) ) - { - if (UseFilter) - { - fuzzy->FilterSet = 1; - memset(fuzzy->FilterMap, 0 , sizeof(fuzzy->FilterMap) ); - fuzzy->FilterS = (Uint *)calloc(m + 1, sizeof(Uint)); + /* If k is zero then no filter is needed! */ + if (fuzzy->k && (p_len >= 2*(fuzzy->k + 1)) ) + { + if (UseFilter) + { + fuzzy->FilterSet = 1; + memset(fuzzy->FilterMap, 0 , sizeof(fuzzy->FilterMap) ); + fuzzy->FilterS = (Uint *)calloc(m + 1, sizeof(Uint)); - /* Not let's fill the interleaved pattern */ - dd = p_len / (fuzzy->k + 1); - p_len = dd * (fuzzy->k + 1); + /* Not let's fill the interleaved pattern */ + dd = p_len / (fuzzy->k + 1); + p_len = dd * (fuzzy->k + 1); - for (i = 0, cnt = 0; i < dd; i++) - for (j = 0; j < fuzzy->k + 1; j++, cnt++) - PatFilter[cnt] = (unsigned char)p[j*dd + i]; - PatFilter[p_len] = 0; + for (i = 0, cnt = 0; i < dd; i++) + for (j = 0; j < fuzzy->k + 1; j++, cnt++) + PatFilter[cnt] = (unsigned char)p[j*dd + i]; + PatFilter[p_len] = 0; - for (i = 0, cnt = 0; i < p_len; i++) - { - l = fuzzy->FilterMap[(unsigned char)PatFilter[i]]; - if (!l) - { - l = fuzzy->FilterMap[(unsigned char)PatFilter[i]] = ++cnt; - fuzzy->FilterS[l] = 0; - } - fuzzy->FilterS[l] |= 1 << i; - } - fuzzy->filter_ok = 0; - for (i = p_len - fuzzy->k - 1; i <= p_len - 1; i++) /* k+1 times */ - fuzzy->filter_ok |= 1 << i; + for (i = 0, cnt = 0; i < p_len; i++) + { + l = fuzzy->FilterMap[(unsigned char)PatFilter[i]]; + if (!l) + { + l = fuzzy->FilterMap[(unsigned char)PatFilter[i]] = ++cnt; + fuzzy->FilterS[l] = 0; + } + fuzzy->FilterS[l] |= 1 << i; + } + fuzzy->filter_ok = 0; + for (i = p_len - fuzzy->k - 1; i <= p_len - 1; i++) /* k+1 times */ + fuzzy->filter_ok |= 1 << i; - /* k+1 first bits set to 1 */ - fuzzy->filter_shift = (1 << (fuzzy->k + 2)) - 1; - } - } + /* k+1 first bits set to 1 */ + fuzzy->filter_shift = (1 << (fuzzy->k + 2)) - 1; + } + } } /****************************************************************************** FUNCTION afuzzy_free() - Cleaning up after previous afuzzy_init() call. + Cleaning up after previous afuzzy_init() call. ARGUMENTS: - fuzzy pointer to the afuzzy parameters structure - + fuzzy pointer to the afuzzy parameters structure + RETURN VALUE: - none + none ******************************************************************************/ void afuzzy_free(AFUZZY *fuzzy) { - if (fuzzy->S) - { - free(fuzzy->S); - fuzzy->S = NULL; - } - if (fuzzy->R) - { - free(fuzzy->R); - fuzzy->R = NULL; - } - if (fuzzy->R1) - { - free(fuzzy->R1); - fuzzy->R1 = NULL; - } - if (fuzzy->RP) - { - free(fuzzy->RP); - fuzzy->RP = NULL; - } - if (fuzzy->RI) - { - free(fuzzy->RI); - fuzzy->RI = NULL; - } - if (fuzzy->FilterS) - { - free(fuzzy->FilterS); - fuzzy->FilterS = NULL; - } + if (fuzzy->S) + { + free(fuzzy->S); + fuzzy->S = NULL; + } + if (fuzzy->R) + { + free(fuzzy->R); + fuzzy->R = NULL; + } + if (fuzzy->R1) + { + free(fuzzy->R1); + fuzzy->R1 = NULL; + } + if (fuzzy->RP) + { + free(fuzzy->RP); + fuzzy->RP = NULL; + } + if (fuzzy->RI) + { + free(fuzzy->RI); + fuzzy->RI = NULL; + } + if (fuzzy->FilterS) + { + free(fuzzy->FilterS); + fuzzy->FilterS = NULL; + } } /****************************************************************************** FUNCTION afuzzy_CheckSUB() - Perform a fuzzy pattern substring matching. afuzzy_init() should be - called previously to initialize the pattern and error length. - Positive result means that some part of the string given matches the - pattern with no more than afuzzy->k errors (1 error = 1 letter - replacement or transposition) + Perform a fuzzy pattern substring matching. afuzzy_init() should be + called previously to initialize the pattern and error length. + Positive result means that some part of the string given matches the + pattern with no more than afuzzy->k errors (1 error = 1 letter + replacement or transposition) ARGUMENTS: - t the string to test - fuzzy pointer to the afuzzy parameters structure + t the string to test + fuzzy pointer to the afuzzy parameters structure RETURN VALUE: - 0 - no match - > 0 - strings match + 0 - no match + > 0 - strings match ALGORITHM - ???????????????? + ???????????????? ******************************************************************************/ int afuzzy_checkSUB(const char *t, AFUZZY *fuzzy) { - register char c; - register int j, d; + register char c; + register int j, d; - /* For eficciency this case should be little bit optimized */ - if (!fuzzy->k) - { - Uint R = 0, R1; + /* For eficciency this case should be little bit optimized */ + if (!fuzzy->k) + { + Uint R = 0, R1; - for (j = 0; (c = t[j]) != '\0'; j++) - { - R1 = ( ((R<<1) | 1) & fuzzy->S[fuzzy->Map[(unsigned char)c]]); - R = R1; + for (j = 0; (c = t[j]) != '\0'; j++) + { + R1 = ( ((R<<1) | 1) & fuzzy->S[fuzzy->Map[(unsigned char)c]]); + R = R1; - if (R1 & fuzzy->mask_ok) - return 1; - } /* end for (register int j = 0 ... */ - return 0; - } + if (R1 & fuzzy->mask_ok) + return 1; + } /* end for (register int j = 0 ... */ + return 0; + } - if (fuzzy->FilterSet && !afuzzy_checkFLT(t, fuzzy)) - return 0; + if (fuzzy->FilterSet && !afuzzy_checkFLT(t, fuzzy)) + return 0; - memcpy(fuzzy->R, fuzzy->RI, fuzzy->r_size); /* R = RI */ + memcpy(fuzzy->R, fuzzy->RI, fuzzy->r_size); /* R = RI */ - for (j = 0; (c = t[j]); j++) - { - for (d = 0; d <= fuzzy->k; d++) - { - fuzzy->R1[d] = (((fuzzy->R[d]<<1) | 1) & - fuzzy->S[fuzzy->Map[(unsigned char)c]]); - if (d > 0) - fuzzy->R1[d] |= ((fuzzy->R[d-1] | fuzzy->R1[d-1])<<1) | 1 | - fuzzy->R[d-1]; - } - if (fuzzy->R1[fuzzy->k] & fuzzy->mask_ok) - return j; + for (j = 0; (c = t[j]); j++) + { + for (d = 0; d <= fuzzy->k; d++) + { + fuzzy->R1[d] = (((fuzzy->R[d]<<1) | 1) & + fuzzy->S[fuzzy->Map[(unsigned char)c]]); + if (d > 0) + fuzzy->R1[d] |= ((fuzzy->R[d-1] | fuzzy->R1[d-1])<<1) | 1 | + fuzzy->R[d-1]; + } + if (fuzzy->R1[fuzzy->k] & fuzzy->mask_ok) + return j; - memcpy(fuzzy->R, fuzzy->R1, fuzzy->r_size); + memcpy(fuzzy->R, fuzzy->R1, fuzzy->r_size); - } /* end for (register int j = 0 ... */ + } /* end for (register int j = 0 ... */ - return 0; + return 0; } int afuzzy_checkFLT(const char *t, AFUZZY *fuzzy) { - register Uint FilterR = 0; - register Uint FilterR1; - register int j; + register Uint FilterR = 0; + register Uint FilterR1; + register int j; - for (j = 0; t[j] != '\0'; j++) - { - FilterR1 = ( ((FilterR<<(fuzzy->k+1)) | fuzzy->filter_shift) & - fuzzy->FilterS[fuzzy->FilterMap[(unsigned char)t[j]]]); - if (FilterR1 & fuzzy->filter_ok) - return 1; - FilterR = FilterR1; - } /* end for (register int j = 0 ... */ + for (j = 0; t[j] != '\0'; j++) + { + FilterR1 = ( ((FilterR<<(fuzzy->k+1)) | fuzzy->filter_shift) & + fuzzy->FilterS[fuzzy->FilterMap[(unsigned char)t[j]]]); + if (FilterR1 & fuzzy->filter_ok) + return 1; + FilterR = FilterR1; + } /* end for (register int j = 0 ... */ - return 0; + return 0; } diff --git a/tools.h b/tools.h index 26212fe..1ee6782 100644 --- a/tools.h +++ b/tools.h @@ -45,21 +45,21 @@ typedef unsigned int Uint; typedef struct { - Uint *R, - *R1, - *RP, - *S, - *RI; - Uint *FilterS; + Uint *R, + *R1, + *RP, + *S, + *RI; + Uint *FilterS; - int Map[256]; - int FilterMap[256]; - int k; - Uint mask_ok; - Uint filter_ok; - Uint filter_shift; - int r_size; - int FilterSet; + int Map[256]; + int FilterMap[256]; + int k; + Uint mask_ok; + Uint filter_ok; + Uint filter_shift; + int r_size; + int FilterSet; } AFUZZY; void afuzzy_init(const char *p, int kerr, int UseFilter, AFUZZY *fuzzy);