source: trunk/zoo-kernel/service.h @ 114

Last change on this file since 114 was 114, checked in by djay, 12 years ago

Code cleanup to avoid most of the warning messages at compilation time.

File size: 15.7 KB
Line 
1/**
2 * Author : Gérald FENOY
3 *
4 * Copyright (c) 2009-2010 GeoLabs SARL
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25#ifndef ZOO_SERVICE_H
26#define ZOO_SERVICE_H 1
27
28#pragma once
29
30#ifdef __cplusplus
31extern "C" {
32#endif
33
34#include <stdlib.h>
35#include <ctype.h>
36#include <stdio.h>
37#include <string.h>
38
39#define bool int
40#define true 1
41#define false -1
42
43#define SERVICE_ACCEPTED 0
44#define SERVICE_STARTED 1
45#define SERVICE_PAUSED 2
46#define SERVICE_SUCCEEDED 3
47#define SERVICE_FAILED 4
48
49#define ELEMENTS_SIZE (sizeof(char*)+(((2*sizeof(char*))+sizeof(maps*))*2)+sizeof(char*)+(((2*sizeof(char*))+sizeof(iotype*))*2)+sizeof(elements*))
50#define MAP_SIZE (2*sizeof(char*))+sizeof(NULL)
51#define IOTYPE_SIZE MAP_SIZE+sizeof(NULL)
52#define MAPS_SIZE (2*sizeof(char*))+sizeof(map*)+MAP_SIZE
53#define SERVICE_SIZE (ELEMENTS_SIZE*2)+(MAP_SIZE*2)+sizeof(char*)
54
55#define SHMSZ     27
56
57
58  /**
59   * \struct map
60   * \brief KVP linked list
61   *
62   * Deal with WPS KVP (name,value).
63   * A map is defined as:
64   *  - name : a key,
65   *  - value: a value,
66   *  - next : a pointer to the next map if any.
67   */
68  typedef struct map{
69    char* name;
70    char* value;
71    struct map* next;
72  } map;
73
74#ifdef WIN32
75#define NULLMAP ((map*) 0)
76#else
77#define NULLMAP NULL
78#endif
79
80  /**
81   * \struct maps
82   * \brief linked list of map pointer
83   *
84   * Small object to store WPS KVP set.
85   * Maps is defined as:
86   *  - a name,
87   *  - a content map,
88   *  - a pointer to the next maps if any.
89   */
90  typedef struct maps{
91    char* name;         
92    struct map* content; 
93    struct maps* next;   
94  } maps;
95
96  /**
97   * \brief Dump a map on stderr
98   */
99  static void _dumpMap(map* t){
100    if(t!=NULL){
101      fprintf(stderr,"[%s] => [%s] \n",t->name,t->value);
102      fflush(stderr);
103    }else{
104      fprintf(stderr,"NULL\n");
105      fflush(stderr);
106    }
107  }
108
109  static void dumpMap(map* t){
110    map* tmp=t;
111    while(tmp!=NULL){
112      _dumpMap(tmp);
113      tmp=tmp->next;
114    }
115  }
116
117  static void dumpMapToFile(map* t,FILE* file){
118    map* tmp=t;
119    while(tmp!=NULL){
120      fprintf(file,"%s = %s\n",t->name,t->value);
121      tmp=tmp->next;
122    }
123  }
124
125  static void dumpMaps(maps* m){
126    maps* tmp=m;
127    while(tmp!=NULL){
128      fprintf(stderr,"MAP => [%s] \n",tmp->name);
129      dumpMap(tmp->content);
130      tmp=tmp->next;
131    }
132  }
133
134  static void dumpMapsToFile(maps* m,FILE* file){
135    maps* tmp=m;
136    if(tmp!=NULL){
137      fprintf(file,"[%s]\n",tmp->name);
138      dumpMapToFile(tmp->content,file);
139    }
140  }
141
142  static map* createMap(const char* name,const char* value){
143    map* tmp=(map *)malloc(MAP_SIZE);
144    tmp->name=strdup(name);
145    tmp->value=strdup(value);
146    tmp->next=NULL;
147    return tmp;
148  }
149
150  static int count(map* m){
151    map* tmp=m;
152    int c=0;
153    while(tmp!=NULL){
154      c++;
155      tmp=tmp->next;
156    }
157    return c;
158  }
159   
160  static bool hasKey(map* m,const char *key){
161    map* tmp=m;
162    while(tmp!=NULL){
163      if(strcasecmp(tmp->name,key)==0)
164        return true;
165      tmp=tmp->next;
166    }
167#ifdef DEBUG_MAP
168    fprintf(stderr,"NOT FOUND \n");
169#endif
170    return false;
171  }
172
173  static maps* getMaps(maps* m,const char *key){
174    maps* tmp=m;
175    while(tmp!=NULL){
176      if(strcasecmp(tmp->name,key)==0){
177        return tmp;
178      }
179      tmp=tmp->next;
180    }
181    return NULL;
182  }
183
184  static map* getMap(map* m,const char *key){
185    map* tmp=m;
186    while(tmp!=NULL){
187      if(strcasecmp(tmp->name,key)==0){
188        return tmp;
189      }
190      tmp=tmp->next;
191    }
192    return NULL;
193  }
194
195  static map* getMapFromMaps(maps* m,const char* key,const char* subkey){
196    maps* _tmpm=getMaps(m,key);
197    if(_tmpm!=NULL){
198      map* _ztmpm=getMap(_tmpm->content,subkey);
199      return _ztmpm;
200    }
201    else return NULL;
202  }
203
204  static void freeMap(map** mo){
205    map* _cursor=*mo;
206    if(_cursor!=NULL){
207#ifdef DEBUG
208      fprintf(stderr,"freeMap\n");
209#endif
210      free(_cursor->name);
211      free(_cursor->value);
212      if(_cursor->next!=NULL){
213        freeMap(&_cursor->next);
214        free(_cursor->next);
215      }
216    }
217  }
218
219  static void freeMaps(maps** mo){
220    maps* _cursor=*mo;
221    fflush(stderr);
222    if(_cursor && _cursor!=NULL){
223#ifdef DEBUG
224      fprintf(stderr,"freeMaps\n");
225#endif
226      free(_cursor->name);
227      if(_cursor->content!=NULL){
228        freeMap(&_cursor->content);
229        free(_cursor->content);
230      }
231      if(_cursor->next!=NULL){
232        freeMaps(&_cursor->next);
233        free(_cursor->next);
234      }
235    }
236  }
237
238  /**
239   * \brief Not named linked list
240   *
241   * Used to store informations about formats, such as mimeType, encoding ...
242   *
243   * An iotype is defined as :
244   *  - a content map,
245   *  - a pointer to the next iotype if any.
246   */
247  typedef struct iotype{
248    struct map* content;
249    struct iotype* next;
250  } iotype;
251
252  /**
253   * \brief Metadata information about input or output.
254   *
255   * The elements are used to store metadata informations defined in the ZCFG.
256   *
257   * An elements is defined as :
258   *  - a name,
259   *  - a content map,
260   *  - a metadata map,
261   *  - a format (possible values are LiteralData, ComplexData or
262   * BoundingBoxData),
263   *  - a default iotype,
264   *  - a pointer to the next elements id any.
265   */
266  typedef struct elements{
267    char* name;
268    struct map* content;
269    struct map* metadata;
270    char* format;
271    struct iotype* defaults;
272    struct iotype* supported;
273    struct elements* next;
274  } elements;
275
276  typedef struct service{
277    char* name;
278    struct map* content;
279    struct map* metadata;
280    struct elements* inputs;
281    struct elements* outputs; 
282  } service;
283
284  typedef struct services{
285    struct service* content; 
286    struct services* next; 
287  } services;
288
289  static bool hasElement(elements* e,const char* key){
290    elements* tmp=e;
291    while(tmp!=NULL){
292      if(strcasecmp(key,tmp->name)==0)
293        return true;
294      tmp=tmp->next;
295    }
296    return false;
297  }
298
299  static elements* getElements(elements* m,char *key){
300    elements* tmp=m;
301    while(tmp!=NULL){
302      if(strcasecmp(tmp->name,key)==0)
303        return tmp;
304      tmp=tmp->next;
305    }
306    return NULL;
307  }
308
309
310  static void freeIOType(iotype** i){
311    iotype* _cursor=*i;
312    if(_cursor!=NULL){
313      if(_cursor->next!=NULL){
314        freeIOType(&_cursor->next);
315        free(_cursor->next);
316      }
317      freeMap(&_cursor->content);
318      free(_cursor->content);
319    }
320  }
321
322  static void freeElements(elements** e){
323    elements* tmp=*e;
324    if(tmp!=NULL){
325      if(tmp->name!=NULL)
326        free(tmp->name);
327      freeMap(&tmp->content);
328      if(tmp->content!=NULL)
329        free(tmp->content);
330      freeMap(&tmp->metadata);
331      if(tmp->metadata!=NULL)
332        free(tmp->metadata);
333      if(tmp->format!=NULL)
334        free(tmp->format);
335      freeIOType(&tmp->defaults);
336      if(tmp->defaults!=NULL)
337        free(tmp->defaults);
338      freeIOType(&tmp->supported);
339      if(tmp->supported!=NULL){
340        free(tmp->supported);
341      }
342      freeElements(&tmp->next);
343      if(tmp->next!=NULL)
344        free(tmp->next);
345    }
346  }
347
348  static void freeService(service** s){
349    service* tmp=*s;
350    if(tmp!=NULL){
351      if(tmp->name!=NULL)
352        free(tmp->name);
353      freeMap(&tmp->content);
354      if(tmp->content!=NULL)
355        free(tmp->content);
356      freeMap(&tmp->metadata);
357      if(tmp->metadata!=NULL)
358        free(tmp->metadata);
359      freeElements(&tmp->inputs);
360      if(tmp->inputs!=NULL)
361        free(tmp->inputs);
362      freeElements(&tmp->outputs);
363      if(tmp->outputs!=NULL)
364        free(tmp->outputs);
365    }
366  }
367
368  static void addToMap(map* m,const char* n,const char* v){
369    if(hasKey(m,n)==false){
370      map* _cursor=m;
371      while(_cursor->next!=NULL)
372        _cursor=_cursor->next;
373      _cursor->next=createMap(n,v);
374    }
375    else{
376      map *tmp=getMap(m,n);
377      if(tmp->value!=NULL)
378        free(tmp->value);
379      tmp->value=strdup(v);
380    }
381  }
382
383  static void addMapToMap(map** mo,map* mi){
384    map* tmp=mi;
385    map* _cursor=*mo;
386    if(tmp==NULL){
387      if(_cursor!=NULL){
388        while(_cursor!=NULL)
389          _cursor=_cursor->next;
390        _cursor=NULL;
391      }else
392        *mo=NULL;
393    }
394    while(tmp!=NULL){
395      if(_cursor==NULL){
396        if(*mo==NULL)
397          *mo=createMap(tmp->name,tmp->value);
398        else
399          addToMap(*mo,tmp->name,tmp->value);
400      }
401      else{
402#ifdef DEBUG
403        fprintf(stderr,"_CURSOR\n");
404        dumpMap(_cursor);
405#endif
406        while(_cursor!=NULL)
407          _cursor=_cursor->next;
408        _cursor=createMap(tmp->name,tmp->value);
409        _cursor->next=NULL;
410      }
411      tmp=tmp->next;
412#ifdef DEBUG
413      fprintf(stderr,"MO\n");
414      dumpMap(*mo);
415#endif
416    }
417  }
418
419  static void addMapToIoType(iotype** io,map* mi){
420    iotype* tmp=*io;
421    while(tmp->next!=NULL){
422      tmp=tmp->next;
423    }
424    tmp->next=(iotype*)malloc(IOTYPE_SIZE);
425    tmp->next->content=NULL;
426    addMapToMap(&tmp->next->content,mi);
427    tmp->next->next=NULL;
428  }
429
430  static bool contains(map* m,map* i){
431    while(i!=NULL){     
432      if(strcasecmp(i->name,"value")!=0 &&
433         strcasecmp(i->name,"xlink:href")!=0){
434        map *tmp;
435        if(hasKey(m,i->name) && (tmp=getMap(m,i->name))!=NULL && 
436           strcasecmp(i->value,tmp->value)!=0)
437          return false;
438      }
439      i=i->next;
440    }
441    return true;
442  }
443
444  static iotype* getIoTypeFromElement(elements* e,char *name, map* values){
445    elements* cursor=e;
446    while(cursor!=NULL){
447      if(strcasecmp(cursor->name,name)==0){
448        if(contains(cursor->defaults->content,values)==true)
449          return cursor->defaults;
450        else{
451          iotype* tmp=cursor->supported;
452          while(tmp!=NULL){
453            if(contains(tmp->content,values)==true)
454              return tmp;           
455            tmp=tmp->next;
456          }
457        }
458      }
459      cursor=cursor->next;
460    }
461    return NULL;
462  }
463
464  static maps* dupMaps(maps** mo){
465    maps* _cursor=*mo;
466    maps* res=NULL;
467    if(_cursor!=NULL){
468      res=(maps*)malloc(MAPS_SIZE);
469      res->name=strdup(_cursor->name);
470      res->content=NULL;
471      res->next=NULL;
472      map* mc=_cursor->content;
473      map* tmp=getMap(mc,"size");
474      char* tmpSized=NULL;
475      if(tmp!=NULL){
476        map* tmpV=getMap(mc,"value");
477        tmpSized=(char*)malloc((atoi(tmp->value)+1)*sizeof(char));
478        memmove(tmpSized,tmpV->value,atoi(tmp->value)*sizeof(char));
479      }
480      if(mc!=NULL){
481        addMapToMap(&res->content,mc);
482      }
483      if(tmp!=NULL){
484        map* tmpV=getMap(res->content,"value");
485        free(tmpV->value);
486        tmpV->value=(char*)malloc(atoi(tmp->value)*sizeof(char));
487        memmove(tmpV->value,tmpSized,atoi(tmp->value)*sizeof(char));
488        free(tmpSized);
489      }
490      res->next=dupMaps(&_cursor->next);
491    }
492    return res;
493  }
494
495  static void addMapsToMaps(maps** mo,maps* mi){
496    maps* tmp=mi;
497    maps* _cursor=*mo;
498    while(tmp!=NULL){
499      if(_cursor==NULL){
500        *mo=dupMaps(&mi);
501        (*mo)->next=NULL;
502      }
503      else{
504        while(_cursor->next!=NULL)
505          _cursor=_cursor->next;
506        _cursor->next=dupMaps(&tmp);
507      }
508      tmp=tmp->next;
509    }
510  }
511
512
513  static void setMapInMaps(maps* m,const char* key,const char* subkey,const char *value){
514    maps* _tmpm=getMaps(m,key);
515    if(_tmpm!=NULL){
516      map* _ztmpm=getMap(_tmpm->content,subkey);
517      if(_ztmpm!=NULL){
518        free(_ztmpm->value);
519        _ztmpm->value=strdup(value);
520      }else{
521        addToMap(_tmpm->content,subkey,value);
522      }
523    }
524  }
525
526
527  static void dumpElements(elements* e){
528    elements* tmp=e;
529    while(tmp!=NULL){
530      fprintf(stderr,"ELEMENT [%s]\n",tmp->name);
531      fprintf(stderr," > CONTENT [%s]\n",tmp->name);
532      dumpMap(tmp->content);
533      fprintf(stderr," > METADATA [%s]\n",tmp->name);
534      dumpMap(tmp->metadata);
535      fprintf(stderr," > FORMAT [%s]\n",tmp->format);
536      iotype* tmpio=tmp->defaults;
537      int ioc=0;
538      while(tmpio!=NULL){
539        fprintf(stderr," > DEFAULTS [%s] (%i)\n",tmp->name,ioc);
540        dumpMap(tmpio->content);
541        tmpio=tmpio->next;
542        ioc++;
543      }
544      tmpio=tmp->supported;
545      ioc=0;
546      while(tmpio!=NULL){
547        fprintf(stderr," > SUPPORTED [%s] (%i)\n",tmp->name,ioc);
548        dumpMap(tmpio->content);
549        tmpio=tmpio->next;
550        ioc++;
551      }
552      fprintf(stderr,"------------------\n");
553      tmp=tmp->next;
554    }
555  }
556
557  static elements* dupElements(elements* e){
558    elements* cursor=e;
559    elements* tmp=NULL;
560    if(cursor!=NULL){
561#ifdef DEBUG
562      fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
563      dumpElements(e);
564      fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
565#endif
566      tmp=(elements*)malloc(ELEMENTS_SIZE);
567      tmp->name=strdup(e->name);
568      tmp->content=NULL;
569      addMapToMap(&tmp->content,e->content);
570      tmp->metadata=NULL;
571      addMapToMap(&tmp->metadata,e->metadata);
572      tmp->format=strdup(e->format);
573      if(e->defaults!=NULL){
574        tmp->defaults=(iotype*)malloc(IOTYPE_SIZE);
575        tmp->defaults->content=NULL;
576        addMapToMap(&tmp->defaults->content,e->defaults->content);
577        tmp->defaults->next=NULL;
578#ifdef DEBUG
579        fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
580        dumpMap(tmp->defaults->content);
581#endif
582      }else
583        tmp->defaults=NULL;
584      if(e->supported!=NULL){
585        tmp->supported=(iotype*)malloc(IOTYPE_SIZE);
586        tmp->supported->content=NULL;
587        addMapToMap(&tmp->supported->content,e->supported->content);
588        tmp->supported->next=NULL;
589        iotype *tmp2=e->supported->next;
590        while(tmp2!=NULL){
591          addMapToIoType(&tmp->supported,tmp2->content);
592#ifdef DEBUG
593          fprintf(stderr,">> %s %i\n",__FILE__,__LINE__);
594          dumpMap(tmp->defaults->content);
595#endif
596          tmp2=tmp2->next;
597        }
598      }
599      else
600        tmp->supported=NULL;
601      tmp->next=dupElements(cursor->next);
602    }
603    return tmp;
604  }
605
606  static void addToElements(elements** m,elements* e){
607    elements* tmp=e;
608    if(*m==NULL){
609      *m=dupElements(tmp);
610    }else{
611      addToElements(&(*m)->next,tmp);
612    }
613  }
614
615  static void dumpService(service* s){
616    fprintf(stderr,"++++++++++++++++++\nSERVICE [%s]\n++++++++++++++++++\n",s->name);
617    if(s->content!=NULL){
618      fprintf(stderr,"CONTENT MAP\n");
619      dumpMap(s->content);
620      fprintf(stderr,"CONTENT METADATA\n");
621      dumpMap(s->metadata);
622    }
623    if(s->inputs!=NULL){
624      fprintf(stderr,"INPUT ELEMENTS [%s]\n------------------\n",s->name);
625      dumpElements(s->inputs);
626    }
627    if(s->outputs!=NULL){
628      fprintf(stderr,"OUTPUT ELEMENTS [%s]\n------------------\n",s->name);
629      dumpElements(s->outputs);
630    }
631    fprintf(stderr,"++++++++++++++++++\n");
632  }
633
634  static void mapsToCharXXX(maps* m,char*** c){
635    maps* tm=m;
636    int i=0;
637    int j=0;
638    char tmp[10][30][1024];
639    memset(tmp,0,1024*10*10);
640    while(tm!=NULL){
641      if(i>=10)
642        break;
643      strcpy(tmp[i][j],"name");
644      j++;
645      strcpy(tmp[i][j],tm->name);
646      j++;
647      map* tc=tm->content;
648      while(tc!=NULL){
649        if(j>=30)
650          break;
651        strcpy(tmp[i][j],tc->name);
652        j++;
653        strcpy(tmp[i][j],tc->value);
654        j++;
655        tc=tc->next;
656      }
657      tm=tm->next;
658      j=0;
659      i++;
660    }
661    memcpy(c,tmp,10*10*1024);
662  }
663
664  static void charxxxToMaps(char*** c,maps**m){
665    maps* trorf=*m;
666    int i,j;
667    char tmp[10][30][1024];
668    memcpy(tmp,c,10*30*1024);
669    for(i=0;i<10;i++){
670      if(strlen(tmp[i][1])==0)
671        break;
672      trorf->name=tmp[i][1];
673      trorf->content=NULL;
674      trorf->next=NULL;
675      for(j=2;j<29;j+=2){
676        if(strlen(tmp[i][j+1])==0)
677          break;
678        if(trorf->content==NULL)
679          trorf->content=createMap(tmp[i][j],tmp[i][j+1]);
680        else
681          addToMap(trorf->content,tmp[i][j],tmp[i][j+1]);
682      }
683      trorf=trorf->next;
684    }
685    m=&trorf;
686  }
687
688#ifdef __cplusplus
689}
690#endif
691
692#endif
Note: See TracBrowser for help on using the repository browser.

Search

ZOO Sponsors

http://www.zoo-project.org/trac/chrome/site/img/geolabs-logo.pnghttp://www.zoo-project.org/trac/chrome/site/img/neogeo-logo.png http://www.zoo-project.org/trac/chrome/site/img/apptech-logo.png http://www.zoo-project.org/trac/chrome/site/img/3liz-logo.png http://www.zoo-project.org/trac/chrome/site/img/gateway-logo.png

Become a sponsor !

Knowledge partners

http://www.zoo-project.org/trac/chrome/site/img/ocu-logo.png http://www.zoo-project.org/trac/chrome/site/img/gucas-logo.png http://www.zoo-project.org/trac/chrome/site/img/polimi-logo.png http://www.zoo-project.org/trac/chrome/site/img/fem-logo.png http://www.zoo-project.org/trac/chrome/site/img/supsi-logo.png http://www.zoo-project.org/trac/chrome/site/img/cumtb-logo.png

Become a knowledge partner

Related links

http://zoo-project.org/img/ogclogo.png http://zoo-project.org/img/osgeologo.png