source: titan/titan/bouquets.h @ 45014

Last change on this file since 45014 was 31372, checked in by nit, 9 years ago

clean

File size: 14.6 KB
Line 
1#ifndef BOUQUETS_H
2#define BOUQUETS_H
3
4void debugbouquet()
5{       
6        struct mainbouquet* mainbouquetnode = mainbouquet;
7        struct bouquet* bouquetnode = NULL;
8
9        while(mainbouquetnode != NULL)
10        {
11                printf("%s\n", mainbouquetnode->name);
12                bouquetnode = mainbouquetnode->bouquet;
13                while(bouquetnode != NULL)
14                {
15                        printf("nr=%d sid=%d %p <%p >%p\n", bouquetnode->nr, bouquetnode->serviceid, bouquetnode, bouquetnode->prev, bouquetnode->next);
16                        bouquetnode = bouquetnode->next;
17                }
18                mainbouquetnode = mainbouquetnode->next;
19        }
20}
21
22struct bouquet* getlastbouquet(struct bouquet* node)
23{
24        struct bouquet *prev = NULL;
25
26        while(node != NULL)
27        {
28                prev = node;
29                node = node->next;
30        }
31
32        return prev;
33}
34
35struct bouquet* getprevbouquetbyservicetype(struct bouquet* first, struct bouquet* node)
36{
37        struct bouquet* prev = NULL;
38
39        if(node == NULL) node = first;
40        if(node == NULL) return NULL;
41
42        prev = node->prev;
43        while(prev != NULL && prev->channel != NULL && prev->channel->servicetype != status.servicetype)
44                prev = prev->prev;
45        if(prev == NULL)
46        {
47                prev = getlastbouquet(first);
48                while(prev != NULL && prev->channel != NULL && prev->channel->servicetype != status.servicetype)
49                        prev = prev->prev;
50        }
51
52        return prev;
53}
54
55struct bouquet* getnextbouquetbyservicetype(struct bouquet* first, struct bouquet* node)
56{
57        struct bouquet* next = NULL;
58
59        if(node == NULL) node = first;
60        if(node == NULL) return NULL;
61
62        next = node->next;
63
64        while(next != NULL && next->channel != NULL && next->channel->servicetype != status.servicetype)
65                next = next->next;
66        if(next == NULL)
67        {
68                next = first;
69                while(next != NULL && next->channel != NULL && next->channel->servicetype != status.servicetype)
70                        next = next->next;
71        }
72
73        return next;
74}
75
76int movebouquetblockdown(struct bouquet* node)
77{
78        int i = 0, ret = 0;
79        struct bouquet* prev = NULL;
80        struct mainbouquet* mainbouquetnode = NULL;
81
82        mainbouquetnode = getmainbouquetbybouquetpointer(node);
83        if(mainbouquetnode == NULL)
84        {
85                err("NULL detect");
86                return 1;
87        }
88
89        if(node == NULL) return 1;
90
91        for(i = 0; i < status.moveblockcount; i++)
92        {
93                if(node == NULL) break;
94                node = node->next;
95                while(node->prev != NULL && node->prev->channel != NULL && node->prev->channel->servicetype != status.servicetype)
96                        node = node->next;
97        }
98
99        for(i = 0; i < status.moveblockcount + 1; i++)
100        {
101                if(node == NULL) break;
102                prev = getprevbouquetbyservicetype(mainbouquetnode->bouquet, node);
103                ret = movebouquetdown(node);
104
105        while(node->prev != NULL && node->prev->channel != NULL && node->prev->channel->servicetype != status.servicetype)
106                        ret = movebouquetdown(node);
107
108                node = prev;
109        }
110
111        return ret;
112}
113
114int movebouquetdown(struct bouquet* node)
115{
116        struct bouquet* prev = NULL, *next = NULL;
117        struct mainbouquet* mainbouquetnode = NULL;
118
119        if(node == NULL) return 1;
120
121        mainbouquetnode = getmainbouquetbybouquetpointer(node);
122        if(mainbouquetnode == NULL)
123        {
124                err("NULL detect");
125                return 1;
126        }
127
128        //only one node
129        if(node->prev == NULL && node->next == NULL)
130                return 0;
131
132        //last node
133        if(node->next == NULL)
134        {
135                if(node->prev != NULL)
136                        node->prev->next = NULL;
137                node->prev = NULL;
138                node->next = mainbouquetnode->bouquet;
139                mainbouquetnode->bouquet->prev = node;
140                mainbouquetnode->bouquet = node;
141                return 99;
142        }
143
144        //haenge node aus
145        if(node->prev != NULL)
146                node->prev->next = node->next;
147        else
148                mainbouquetnode->bouquet = node->next;
149        node->next->prev = node->prev;
150
151        //save nodes next and prev
152        next = node->next;
153        prev = node->prev;
154
155        //haenge es eine pos nacher ein
156        node->next = next->next;
157        node->prev = next;
158       
159        if(next->next != NULL)
160                next->next->prev = node;
161        next->next = node;
162
163        status.writebouquet = 1;
164        return 0;
165}
166
167int movebouquetblockup(struct bouquet* node)
168{
169        int i = 0, ret = 0;
170        struct bouquet* next = NULL;
171        struct mainbouquet* mainbouquetnode = NULL;
172
173        mainbouquetnode = getmainbouquetbybouquetpointer(node);
174        if(mainbouquetnode == NULL)
175        {
176                err("NULL detect");
177                return 1;
178        }
179
180        if(node == NULL) return 1;
181
182        for(i = 0; i < status.moveblockcount + 1; i++)
183        {
184                if(node == NULL) break;
185                next = getnextbouquetbyservicetype(mainbouquetnode->bouquet, node);
186                ret = movebouquetup(node);
187
188                while(node->next != NULL && node->next->channel != NULL && node->next->channel->servicetype != status.servicetype)
189                        ret = movebouquetup(node);
190
191                node = next;
192        }
193
194        return ret;
195}
196
197int movebouquetup(struct bouquet* node)
198{
199        struct bouquet* prev = NULL, *next = NULL, *last = NULL;
200        struct mainbouquet* mainbouquetnode = NULL;
201
202        if(node == NULL) return 1;
203
204        mainbouquetnode = getmainbouquetbybouquetpointer(node);
205        if(mainbouquetnode == NULL)
206        {
207                err("NULL detect");
208                return 1;
209        }
210
211        //only one node
212        if(node->prev == NULL && node->next == NULL)
213                return 0;
214
215        //first node
216        if(node->prev == NULL)
217        {
218                last = getlastbouquet(mainbouquetnode->bouquet);
219
220                if(node->next != NULL)
221                        node->next->prev = NULL;
222                mainbouquetnode->bouquet = node->next;
223                node->next = NULL;
224                last->next = node;
225                node->prev = last;
226                return 99;
227        }
228
229        //haenge node aus
230        node->prev->next = node->next;
231        if(node->next != NULL)
232                node->next->prev = node->prev;
233
234        //save nodes next and prev
235        next = node->next;
236        prev = node->prev;
237
238        //haenge es eine pos voher ein
239        node->next = prev;
240        node->prev = prev->prev;
241       
242        if(prev->prev != NULL)
243                prev->prev->next = node;
244        else
245                mainbouquetnode->bouquet = node;
246        prev->prev = node;
247
248        status.writebouquet = 1;
249        return 0;
250}
251
252struct bouquet* getbouquetbychannel(struct bouquet* node, int serviceid, uint64_t transponderid)
253{
254        while(node != NULL)
255        {
256                if(node->channel != NULL && node->channel->serviceid == serviceid && node->channel->transponderid == transponderid)
257                        return node;
258                node = node->next;
259        }
260        return NULL;
261}
262
263struct bouquet* getbouquetbynr(int nr)
264{
265        struct mainbouquet* mainbouquetnode = mainbouquet;
266        struct bouquet* bouquetnode = NULL;
267
268        while(mainbouquetnode != NULL)
269        {
270                bouquetnode = mainbouquetnode->bouquet;
271                while(bouquetnode != NULL)
272                {
273                        if(bouquetnode->channel != NULL && bouquetnode->channel->servicetype == status.servicetype && bouquetnode->nr == nr)
274                                return bouquetnode;
275
276                        bouquetnode = bouquetnode->next;
277                }
278                mainbouquetnode = mainbouquetnode->next;
279        }
280
281        return NULL;
282}
283
284struct bouquet* addbouquet(struct bouquet **firstnode, char *line, int type, int count, struct bouquet* last)
285{
286        struct bouquet *newnode = NULL, *prev = NULL, *node = *firstnode;
287        int ret = 0;
288
289        newnode = (struct bouquet*)calloc(1, sizeof(struct bouquet));
290        if(newnode == NULL)
291        {
292                err("no memory");
293                return NULL;
294        }
295
296        status.writebouquet = 1;
297
298        ret = sscanf(line, "%d#%llu", &newnode->serviceid, &newnode->transponderid);
299        if(ret != 2)
300        {
301                if(count > 0)
302                {
303                        err("bouquet line %d not ok", count);
304                }
305                else
306                {
307                        err("add bouquet");
308                }
309                free(newnode);
310                return NULL;
311        }
312
313        newnode->channel = getchannel(newnode->serviceid, newnode->transponderid);
314        if(newnode->channel == NULL)
315        {
316                err("bouquet line %d not ok (channel not found)", count);
317                free(newnode);
318                return NULL;
319        }
320
321        if(type < MAXSERVICETYPE)
322        {
323                status.bouquetnr[type]++;
324                newnode->nr = status.bouquetnr[type];
325        }
326
327        if(last == NULL)
328        {
329                while(node != NULL)
330                {
331                        prev = node;
332                        node = node->next;
333                }
334        }
335        else
336        {
337                prev = last;
338                node = last->next;
339        }
340
341        if(prev == NULL)
342                *firstnode = newnode;
343        else
344        {
345                prev->next = newnode;
346                newnode->prev = prev;
347        }
348        newnode->next = node;
349        if(node != NULL) node->prev = newnode;
350
351        return newnode;
352}
353
354void recalcbouquetnr()
355{
356        int i;
357        struct mainbouquet* node = mainbouquet;
358        struct bouquet* bouquetnode = NULL;
359
360        for(i = 0; i < MAXSERVICETYPE; i++)
361                status.bouquetnr[i] = 0;
362
363        while(node != NULL)
364        {
365                bouquetnode = node->bouquet;
366                while(bouquetnode != NULL)
367                {
368                        if(node->type < MAXSERVICETYPE)
369                        {
370                                status.bouquetnr[node->type]++;
371                                bouquetnode->nr = status.bouquetnr[node->type];
372                        }
373                        bouquetnode = bouquetnode->next;
374                }
375                node = node->next;
376        }
377}
378
379int readbouquet(char* filename, struct bouquet** firstnode, int type)
380{
381        FILE *fd = NULL;
382        char *fileline = NULL;
383        int linecount = 0, len = 0;
384        struct bouquet* last = NULL, *tmplast = NULL;
385
386        fileline = malloc(MINMALLOC);
387        if(fileline == NULL)
388        {
389                err("no memory");
390                return 1;
391        }
392
393        fd = fopen(filename, "r");
394        if(fd == NULL)
395        {
396                perr("can't open %s", filename);
397                free(fileline);
398                return 1;
399        }
400
401        while(fgets(fileline, MINMALLOC, fd) != NULL)
402        {
403                if(fileline[0] == '#' || fileline[0] == '\n')
404                        continue;
405                len = strlen(fileline) - 1;
406                if(len >= 0 && fileline[len] == '\n')
407                        fileline[len] = '\0';
408                len--;
409                if(len >= 0 && fileline[len] == '\r')
410                        fileline[len] = '\0';
411
412                linecount++;
413
414                if(last == NULL) last = tmplast;
415                last = addbouquet(firstnode, fileline, type, linecount, last);
416                if(last != NULL) tmplast = last;
417        }
418
419        status.writebouquet = 0;
420        free(fileline);
421        fclose(fd);
422        return 0;
423}
424
425void delbouquet(int serviceid, uint64_t transponderid, struct bouquet** firstnode)
426{
427        struct bouquet *node = *firstnode, *prev = *firstnode;
428
429        while(node != NULL)
430        {
431                if(node->serviceid == serviceid && node->transponderid == transponderid)
432                {
433                        status.writebouquet = 1;
434                        if(node == *firstnode)
435                        {
436                                *firstnode = node->next;
437                                if(*firstnode != NULL)
438                                        node->next->prev = NULL;
439                        }
440                        else
441                        {
442                                prev->next = node->next;
443                                if(node->next != NULL)
444                                        node->next->prev = prev;
445                        }
446
447                        free(node);
448                        node = NULL;
449                        break;
450                }
451
452                prev = node;
453                node = node->next;
454        }
455}
456
457void setbouquetchanneltonullmain(int serviceid, uint64_t transponderid)
458{
459        struct mainbouquet* node = mainbouquet;
460        struct bouquet* bouquetnode = NULL;
461
462        while(node != NULL)
463        {
464                bouquetnode = node->bouquet;
465                while(bouquetnode != NULL)
466                {
467                        if(bouquetnode->channel != NULL && bouquetnode->channel->serviceid == serviceid && bouquetnode->channel->transponderid == transponderid)
468                                bouquetnode->channel = NULL;
469                        bouquetnode = bouquetnode->next;
470                }
471                node = node->next;
472        }
473}
474
475void delbouquetbychannel(int serviceid, uint64_t transponderid)
476{
477        struct mainbouquet* node = mainbouquet;
478
479        while(node != NULL)
480        {
481                if(node->bouquet != NULL)
482                        delbouquet(serviceid, transponderid, &node->bouquet);
483                node = node->next;
484        }
485}
486
487//flag: 0 = del bouquet
488//flag: 1 = do not del bouquet
489void delunusedbouquetchannels(int flag)
490{
491        struct mainbouquet* mainbouquetnode = mainbouquet;
492        struct bouquet *node = NULL, *prev = NULL;
493        struct channel* chnode = NULL;
494
495        while(mainbouquetnode != NULL)
496        {
497                prev = mainbouquetnode->bouquet;
498                node = mainbouquetnode->bouquet;
499                while(node != NULL)
500                {
501                        prev = node;
502                        node = node->next;
503                        chnode = getchannel(prev->serviceid, prev->transponderid);
504                        if(chnode == NULL && flag == 0)
505                                delbouquet(prev->serviceid, prev->transponderid, &mainbouquetnode->bouquet);
506                        else
507                                prev->channel = chnode;
508                }
509                mainbouquetnode = mainbouquetnode->next;
510        }
511}
512
513void freebouquet(struct bouquet** firstnode)
514{
515        struct bouquet *node = *firstnode, *prev = *firstnode;
516
517        while(node != NULL)
518        {
519                prev = node;
520                node = node->next;
521                if(prev != NULL)
522                        delbouquet(prev->serviceid, prev->transponderid, firstnode);
523        }
524}
525
526struct bouquet* sortbouquet(struct bouquet **nodeaddr)
527{
528        struct bouquet *nodea = NULL, *nodeb = NULL, *nodec = NULL, *noded = NULL;
529        struct bouquet *nodetmp = NULL;
530
531        if(nodeaddr == NULL || *nodeaddr == NULL)
532        {
533                err("NULL detect");
534                return NULL;
535        }
536       
537        struct bouquet *node = *nodeaddr;
538
539        if(node != NULL)
540        {
541                while(noded != node->next)
542                {
543                        nodec = node;
544                        nodea = node;
545                        nodeb = nodea->next;
546
547                        while(nodea != noded)
548                        {
549                                struct channel *chnode_a = getchannel(nodea->serviceid, nodea->transponderid);
550                                struct channel *chnode_b = getchannel(nodeb->serviceid, nodeb->transponderid);
551                                if(chnode_a != NULL && chnode_b != NULL && strcasecmp(chnode_a->name, chnode_b->name) > 0)
552                                {
553                                        if(nodea == node)
554                                        {
555                                                nodetmp = nodeb->next;
556                                                nodeb->next = nodea;
557                                                nodea->next = nodetmp;
558                                                node = nodeb;
559                                                *nodeaddr = nodeb;
560                                                nodec = nodeb;
561                                        }
562                                        else
563                                        {
564                                                nodetmp = nodeb->next;
565                                                nodeb->next = nodea;
566                                                nodea->next = nodetmp;
567                                                nodec->next = nodeb;
568                                                nodec = nodeb;
569                                        }
570                                }
571                                else
572                                {
573                                        nodec = nodea;
574                                        nodea = nodea->next;
575                                }
576                                nodeb = nodea->next;
577                                if (nodeb == noded)
578                                        noded = nodea;
579                        }
580                }
581        }
582
583        //calc prev
584        struct bouquet* prev = NULL;
585        nodetmp = node;
586        while(nodetmp != NULL)
587        {
588                nodetmp->prev = prev;
589                prev = nodetmp;
590
591                nodetmp = nodetmp->next;
592        }
593
594        status.writebouquet = 1;
595        return *nodeaddr;
596}
597
598/*
599struct bouquet* sortbouquet(struct bouquet **nodeaddr)
600{
601        struct bouquet *tmpnode[10] = {0};
602        struct bouquet *tnode = NULL;
603        struct bouquet *next = NULL, *prev = NULL;
604        struct bouquet **tnodeaddr = NULL;
605       
606        if(nodeaddr == NULL || *nodeaddr == NULL) return NULL;
607       
608        struct bouquet *node = *nodeaddr;
609        while(node != NULL)
610        {
611                next = node->next;
612                prev = NULL;
613
614                if(strcasecmp("c", node->name) > 0) {tnode = tmpnode[0]; tnodeaddr = &tmpnode[0];}
615                else if(strcasecmp("f", node->name) > 0) {tnode = tmpnode[1]; tnodeaddr = &tmpnode[1];}
616                else if(strcasecmp("i", node->name) > 0) {tnode = tmpnode[2]; tnodeaddr = &tmpnode[2];}
617                else if(strcasecmp("l", node->name) > 0) {tnode = tmpnode[3]; tnodeaddr = &tmpnode[3];}
618                else if(strcasecmp("o", node->name) > 0) {tnode = tmpnode[4]; tnodeaddr = &tmpnode[4];}
619                else if(strcasecmp("r", node->name) > 0) {tnode = tmpnode[5]; tnodeaddr = &tmpnode[5];}
620                else if(strcasecmp("u", node->name) > 0) {tnode = tmpnode[6]; tnodeaddr = &tmpnode[6];}
621                else if(strcasecmp("x", node->name) > 0) {tnode = tmpnode[7]; tnodeaddr = &tmpnode[7];}
622                else if(strcasecmp("z", node->name) > 0) {tnode = tmpnode[8]; tnodeaddr = &tmpnode[8];}
623                else {tnode = tmpnode[9]; tnodeaddr = &tmpnode[9];}
624
625                struct channel *chnode_a = getchannel(node->serviceid, node->transponderid);
626                while(tnode != NULL)
627                {
628                        struct channel *chnode_b = getchannel(tnode->serviceid, tnode->transponderid);
629                        if(chnode_a != NULL && chnode_b != NULL && strcasecmp(chnode_a->name, chnode_b->name) <= 0) break;
630                        prev = tnode;
631                        tnode = tnode->next;
632                }
633
634                if(prev == NULL)
635                {
636                        *tnodeaddr = node;
637                        node->prev = NULL;
638                }
639                else
640                {
641                        prev->next = node;
642                        node->prev = prev;
643                }
644                node->next = tnode;
645                if(tnode != NULL) tnode->prev = node;
646
647                node = next;
648        }
649
650        int i = 0, first = 0;
651        prev = NULL; node = NULL;
652        for(i = 0; i < 10; i++)
653        {
654                if(tmpnode[i] != NULL)
655                {
656                        if(prev != NULL)
657                        {
658                                prev->next = tmpnode[i];
659                                tmpnode[i]->prev = prev;
660                        }
661
662                        if(first == 0)
663                        {
664                                *nodeaddr = tmpnode[i];
665                                first = 1;
666                        }
667
668                        node = tmpnode[i];
669                        while(node != NULL)
670                        {
671                                prev = node;
672                                node = node->next;
673                        }
674                }
675        }
676
677        status.writebouquet = 1;
678        return *nodeaddr;
679}
680*/
681
682int writebouquet(const char *filename, struct bouquet *node)
683{
684        FILE *fd = NULL;
685        int ret = 0;
686
687        fd = fopen(filename, "w");
688        if(fd == NULL)
689        {
690                perr("can't open %s", filename);
691                return 1;
692        }
693
694        while(node != NULL)
695        {
696                ret = fprintf(fd, "%d#%llu\n", node->serviceid, node->transponderid);
697                if(ret < 0)
698                {
699                        perr("writting file %s", filename);
700                }
701                node = node->next;
702        }
703
704        fclose(fd);
705        return 0;
706}
707
708#endif
Note: See TracBrowser for help on using the repository browser.