summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--switchtimer.c12
-rw-r--r--switchtimer.h10
-rw-r--r--timerconflict.c20
-rw-r--r--tools.c482
-rw-r--r--tools.h28
5 files changed, 271 insertions, 281 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<std::string> flds3 = s3.split('#');
std::vector<int> 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<std::string>& 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, "<epgsearch>");
- char* endaux = strstr(descr, "</epgsearch>");
- if (!beginaux || !endaux) {
+ if (isempty(aux))
+ return NULL;
+
+ char* descr = strdup(aux);
+ char* beginaux = strstr(descr, "<epgsearch>");
+ char* endaux = strstr(descr, "</epgsearch>");
+ if (!beginaux || !endaux) {
+ free(descr);
+ return NULL;
+ }
+
+ beginaux += 11; // strlen("<epgsearch>");
+ endaux[0] = 0;
+ memmove(descr, beginaux, endaux - beginaux + 1);
+
+ 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;
+
+ char* cat = strcasestr(descr, catname);
+ if (!cat) {
free(descr);
- return NULL;
- }
-
- beginaux += 11; // strlen("<epgsearch>");
- endaux[0] = 0;
- memmove(descr, beginaux, endaux - beginaux + 1);
-
- 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;
-
- char* cat = strcasestr(descr, catname);
- if (!cat) {
- free(descr);
- return NULL;
+ return NULL;
}
- cat += namelen + 2;
- char* end = strstr(cat, "</");
- if (!end) {
- free(descr);
- return NULL;
+ cat += namelen + 2;
+ char* end = strstr(cat, "</");
+ if (!end) {
+ free(descr);
+ return NULL;
}
- end[0] = 0;
+ end[0] = 0;
- int catlen = end - cat + 1;
- char* value = (char *) malloc(catlen);
- memcpy(value, cat, catlen);
+ int catlen = end - cat + 1;
+ char* value = (char *) malloc(catlen);
+ memcpy(value, cat, catlen);
- free(descr);
- return value;
+ free(descr);
+ return value;
}
char* GetAuxValue(const cRecording *recording, const char* name) {
- if (!recording || !recording->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];
-
- 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);
-
- 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 (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;
-
- 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));
-
- /* 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 < 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;
- }
- }
+ 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) );
+
+ 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));
+
+ 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;
+
+ 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 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);
+
+ 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;
+
+ /* 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;
-
- /* 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;
-
- if (R1 & fuzzy->mask_ok)
- return 1;
- } /* end for (register int j = 0 ... */
- return 0;
- }
-
- if (fuzzy->FilterSet && !afuzzy_checkFLT(t, fuzzy))
- return 0;
-
- 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;
-
- memcpy(fuzzy->R, fuzzy->R1, fuzzy->r_size);
-
- } /* end for (register int j = 0 ... */
-
- return 0;
+ register char c;
+ register int j, d;
+
+ /* 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;
+
+ if (R1 & fuzzy->mask_ok)
+ return 1;
+ } /* end for (register int j = 0 ... */
+ return 0;
+ }
+
+ if (fuzzy->FilterSet && !afuzzy_checkFLT(t, fuzzy))
+ return 0;
+
+ 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;
+
+ memcpy(fuzzy->R, fuzzy->R1, fuzzy->r_size);
+
+ } /* end for (register int j = 0 ... */
+
+ return 0;
}
int afuzzy_checkFLT(const char *t, AFUZZY *fuzzy)
{
- 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 ... */
-
- return 0;
+ 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 ... */
+
+ 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);
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-11 21:55:20 +0000