source: titan/titan/mostzap.h @ 39037

Last change on this file since 39037 was 23286, checked in by nit, 11 years ago

[titan] cleanup

File size: 4.8 KB
Line 
1#ifndef MOSTZAP_H
2#define MOSTZAP_H
3
4void mostzaptobouquet(struct mainbouquet* mbouquet)
5{
6        int count = 0;
7        struct mostzap* mnode = mostzap;
8        struct bouquet* last = NULL;
9        char* tmpstr = NULL;
10
11        if(mbouquet == NULL) return;
12
13        freebouquet(&mbouquet->bouquet);
14        while(mnode != NULL)
15        {
16                tmpstr = ostrcat(tmpstr, oitoa(mnode->serviceid), 1, 1);
17                tmpstr = ostrcat(tmpstr, "#", 1, 0);
18                tmpstr = ostrcat(tmpstr, ollutoa(mnode->transponderid), 1, 1);
19                last = addbouquet(&mbouquet->bouquet, tmpstr, 0, 1, last);
20                free(tmpstr); tmpstr = NULL;
21
22                count++;
23                if(count > 29) break;
24
25                mnode = mnode->next;
26        }
27}
28
29struct mostzap* getmostzap(int serviceid, uint64_t transponderid)
30{
31        struct mostzap* mnode = mostzap;
32
33        while(mnode != NULL)
34        {
35                if(mnode->transponderid == transponderid && mnode->serviceid == serviceid)
36                        return mnode;
37                mnode = mnode->next;
38        }
39
40        return NULL;
41}
42
43int movemostzapup(struct mostzap* node)
44{
45        struct mostzap* prev = NULL, *next = NULL;
46
47        if(node == NULL || mostzap == NULL)
48        {
49                err("NULL detect");
50                return 1;
51        }
52
53        //first node
54        if(node->prev == NULL)
55                return 0;
56
57        //haenge node aus
58        node->prev->next = node->next;
59        if(node->next != NULL)
60                node->next->prev = node->prev;
61
62        //save nodes next and prev
63        next = node->next;
64        prev = node->prev;
65
66        //haenge es eine pos voher ein
67        node->next = prev;
68        node->prev = prev->prev;
69       
70        if(prev->prev != NULL)
71                prev->prev->next = node;
72        else
73                mostzap = node;
74        prev->prev = node;
75
76        status.writemostzap = 1;
77        return 0;
78}
79
80struct mostzap* addmostzap(char* line, int count, struct mostzap* last)
81{
82        struct mostzap *newnode = NULL, *prev = NULL, *node = mostzap;
83        int ret = 0;
84
85        if(line == NULL) return NULL;
86
87        newnode = (struct mostzap*)calloc(1, sizeof(struct mostzap));
88        if(newnode == NULL)
89        {
90                err("no memory");
91                return NULL;
92        }
93
94        ret = sscanf(line, "%d#%llu#%d", &newnode->serviceid, &newnode->transponderid, &newnode->count);
95
96        status.writemostzap = 1;
97
98        if(last == NULL)
99        {
100                while(node != NULL && newnode->count < node->count)
101                {
102                        prev = node;
103                        node = node->next;
104                }
105        }
106        else
107        {
108                prev = last;
109                node = last->next;
110        }
111
112        if(prev == NULL)
113                mostzap = newnode;
114        else
115        {
116                prev->next = newnode;
117                newnode->prev = prev;
118        }
119        newnode->next = node;
120        if(node != NULL) node->prev = newnode;
121       
122        return newnode;
123}
124
125struct mostzap* createmostzap(int serviceid, uint64_t transponderid)
126{
127        struct mostzap* mnode = NULL;
128        char* tmpstr = NULL;
129
130        mnode = getmostzap(serviceid, transponderid);
131        if(mnode != NULL)
132        {
133                mnode->count++;
134                while(mnode->prev != NULL && mnode->prev->count < mnode->count)
135                        movemostzapup(mnode);
136                return mnode;
137        }
138
139        tmpstr = ostrcat(tmpstr, oitoa(serviceid), 1, 1);
140        tmpstr = ostrcat(tmpstr, "#", 1, 0);
141        tmpstr = ostrcat(tmpstr, ollutoa(transponderid), 1, 1);
142        tmpstr = ostrcat(tmpstr, "#", 1, 0);
143        tmpstr = ostrcat(tmpstr, "0", 1, 0);
144
145        mnode = addmostzap(tmpstr, 1, NULL);
146        free(tmpstr);
147        return mnode;
148}
149
150int readmostzap(const char* filename)
151{
152        FILE *fd = NULL;
153        char *fileline = NULL;
154        int linecount = 0, len = 0;
155
156        fileline = malloc(MINMALLOC);
157        if(fileline == NULL)
158        {
159                err("no memory");
160                return 1;
161        }
162
163        fd = fopen(filename, "r");
164        if(fd == NULL)
165        {
166                perr("can't open %s", filename);
167                free(fileline);
168                return 1;
169        }
170
171        while(fgets(fileline, MINMALLOC, fd) != NULL)
172        {
173                if(fileline[0] == '#' || fileline[0] == '\n')
174                        continue;
175                len = strlen(fileline) - 1;
176                if(len >= 0 && fileline[len] == '\n')
177                        fileline[len] = '\0';
178                len--;
179                if(len >= 0 && fileline[len] == '\r')
180                        fileline[len] = '\0';
181
182                linecount++;
183
184                addmostzap(fileline, linecount, NULL);
185        }
186
187        status.writemostzap = 0;
188        free(fileline);
189        fclose(fd);
190        return 0;
191}
192
193int delmostzap(int serviceid, uint64_t transponderid, int flag)
194{
195        int ret = 1;
196        struct mostzap *node = mostzap, *prev = mostzap;
197
198        while(node != NULL)
199        {
200                if(node->serviceid == serviceid && node->transponderid == transponderid)
201                {
202                        ret = 0;
203                        if(node == mostzap)
204                        {
205                                mostzap = node->next;
206                                if(mostzap != NULL)
207                                        mostzap->prev = NULL;
208                        }
209                        else
210                        {
211                                prev->next = node->next;
212                                if(node->next != NULL)
213                                        node->next->prev = prev;
214                        }
215
216                        free(node);
217                        node = NULL;
218
219                        break;
220                }
221
222                prev = node;
223                node = node->next;
224        }
225
226        return ret;
227}
228
229void freemostzap(int flag)
230{
231        struct mostzap *node = mostzap, *prev = mostzap;
232
233        while(node != NULL)
234        {
235                prev = node;
236                node = node->next;
237                if(prev != NULL)
238                        delmostzap(prev->serviceid, prev->transponderid, flag);
239        }
240}
241
242int writemostzap(const char *filename)
243{
244        FILE *fd = NULL;
245        struct mostzap *node = mostzap;
246        int ret = 0, count = 0;;
247
248        fd = fopen(filename, "w");
249        if(fd == NULL)
250        {
251                perr("can't open %s", filename);
252                return 1;
253        }
254
255        while(node != NULL)
256        {
257                ret = fprintf(fd, "%d#%llu#%d\n", node->serviceid, node->transponderid, node->count);
258                if(ret < 0)
259                {
260                        perr("writting file %s", filename);
261                }
262
263                count++;
264                if(count > 29) break;
265
266                node = node->next;
267        }
268
269        fclose(fd);
270        return 0;
271}
272
273#endif
Note: See TracBrowser for help on using the repository browser.