Ticket #2032: rfc24-mapandlayers-demo.patch

File rfc24-mapandlayers-demo.patch, 152.9 kB (added by unicoletti, 2 years ago)

Example implementation of rfc24 limited to the map and layer objects

  • mapcontext.c

    old new  
    11451145  layerObj *layer; 
    11461146 
    11471147  /* Init new layer */ 
    1148   layer = &(map->layers[map->numlayers]); 
     1148  layer = &(GET_LAYER(map, map->numlayers)); 
    11491149  initLayer(layer, map); 
    11501150  layer->map = (mapObj *)map; 
    11511151  layer->type = MS_LAYER_RASTER; 
    11521152  /* save the index */ 
    1153   map->layers[map->numlayers].index = map->numlayers; 
     1153  GET_LAYER(map, map->numlayers)->index = map->numlayers; 
    11541154  map->layerorder[map->numlayers] = map->numlayers; 
    11551155  map->numlayers++; 
    11561156   
     
    19191919  /* Loop on all layer   */ 
    19201920  for(i=0; i<map->numlayers; i++) 
    19211921  { 
    1922       if(map->layers[i].status != MS_DELETE && map->layers[i].connectiontype == MS_WMS) 
     1922      if(GET_LAYER(map, i)->status != MS_DELETE && GET_LAYER(map, i)->connectiontype == MS_WMS) 
    19231923      { 
    1924           if(map->layers[i].status == MS_OFF) 
     1924          if(GET_LAYER(map, i)->status == MS_OFF) 
    19251925              nValue = 1; 
    19261926          else 
    19271927              nValue = 0; 
    19281928          msIO_fprintf(stream, "    <Layer queryable=\"%d\" hidden=\"%d\">\n",  
    1929                   msIsLayerQueryable(&(map->layers[i])), nValue); 
     1929                  msIsLayerQueryable(&(GET_LAYER(map, i))), nValue); 
    19301930 
    19311931          /*  */ 
    19321932          /* Server definition */ 
    19331933          /*  */ 
    19341934          if(nVersion <= OWS_1_0_0 ) 
    1935               msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1935              msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19361936                                       NULL, "wms_server_version", OWS_WARN, 
    19371937                             "      <Server service=\"WMS\" version=\"%s\" ", 
    19381938                                       "1.0.0"); 
    19391939          else 
    1940               msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1940              msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19411941                                       NULL, "wms_server_version", OWS_WARN, 
    19421942                          "      <Server service=\"OGC:WMS\" version=\"%s\" ", 
    19431943                                       "1.0.0"); 
    1944           if(map->layers[i].name) 
    1945               msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1944          if(GET_LAYER(map, i)->name) 
     1945              msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19461946                                       NULL, "wms_title", OWS_NOERR,  
    1947                                        "title=\"%s\">\n", map->layers[i].name); 
     1947                                       "title=\"%s\">\n", GET_LAYER(map, i)->name); 
    19481948          else 
    19491949          { 
    1950               msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1950              msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19511951                                       NULL, "wms_title", OWS_NOERR,  
    19521952                                       "title=\"%s\">\n", ""); 
    19531953          } 
    19541954 
    19551955          /* Get base url of the online resource to be the default value */ 
    1956           if(map->layers[i].connection) 
    1957               pszValue = strdup( map->layers[i].connection ); 
     1956          if(GET_LAYER(map, i)->connection) 
     1957              pszValue = strdup( GET_LAYER(map, i)->connection ); 
    19581958          else 
    19591959              pszValue = strdup( "" ); 
    19601960          pszChar = strchr(pszValue, '?'); 
    19611961          if( pszChar ) 
    19621962              pszValue[pszChar - pszValue] = '\0'; 
    1963           if(msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1963          if(msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19641964                                      NULL, "wms_onlineresource", OWS_WARN,  
    19651965         "        <OnlineResource xlink:type=\"simple\" xlink:href=\"%s\"/>\n", 
    19661966                                      pszValue) == OWS_WARN) 
     
    19731973          /*  */ 
    19741974          /* Layer information */ 
    19751975          /*  */ 
    1976           msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1976          msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19771977                             NULL, "wms_name", OWS_WARN,  
    19781978                             "      <Name>%s</Name>\n",  
    1979                              map->layers[i].name); 
    1980           msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1979                             GET_LAYER(map, i)->name); 
     1980          msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19811981                             NULL, "wms_title", OWS_WARN,  
    19821982                             "      <Title>%s</Title>\n",  
    1983                              map->layers[i].name); 
    1984           msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1983                             GET_LAYER(map, i)->name); 
     1984          msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19851985                             NULL, "wms_abstract", OWS_NOERR,  
    19861986                             "      <Abstract>%s</Abstract>\n",  
    19871987                             NULL); 
     
    19891989          /* DataURL */ 
    19901990          if(nVersion <= OWS_0_1_4) 
    19911991          { 
    1992               msOWSPrintEncodeMetadata(stream, &(map->layers[i].metadata),  
     1992              msOWSPrintEncodeMetadata(stream, &(GET_LAYER(map, i)->metadata),  
    19931993                                 NULL, "wms_dataurl", OWS_NOERR,  
    19941994                                 "      <DataURL>%s</DataURL>\n",  
    19951995                                 NULL); 
     
    20022002              /* Note: in version 0.1.7 the width and height are not included  */ 
    20032003              /* in the Context file, but they are included in the metadata for */ 
    20042004              /* for consistency with the URLType. */ 
    2005               msOWSPrintURLType(stream, &(map->layers[i].metadata), "MO",  
     2005              msOWSPrintURLType(stream, &(GET_LAYER(map, i)->metadata), "MO",  
    20062006                                "dataurl", OWS_NOERR, NULL, "DataURL", NULL,  
    20072007                                " width=\"%s\"", " height=\"%s\"", 
    20082008                                " format=\"%s\"",  
     
    20162016          /* The MetadataURL have a width, height, format and an URL */ 
    20172017          /* The metadata will be structured like this:  */ 
    20182018          /* "width height format url" */ 
    2019           msOWSPrintURLType(stream, &(map->layers[i].metadata), "MO",  
     2019          msOWSPrintURLType(stream, &(GET_LAYER(map, i)->metadata), "MO",  
    20202020                            "metadataurl", OWS_NOERR, NULL, "MetadataURL",NULL, 
    20212021                            " width=\"%s\"", " height=\"%s\""," format=\"%s\"", 
    20222022                            "        <OnlineResource xlink:type=\"simple\"" 
     
    20252025                            MS_TRUE, NULL, NULL, NULL, NULL, NULL, "      "); 
    20262026 
    20272027          /* MinScale && MaxScale */ 
    2028           if(nVersion >= OWS_1_1_0 && map->layers[i].minscale > 0) 
     2028          if(nVersion >= OWS_1_1_0 && GET_LAYER(map, i)->minscale > 0) 
    20292029              msIO_fprintf(stream,  
    20302030               "      <sld:MinScaleDenominator>%g</sld:MinScaleDenominator>\n", 
    2031                            map->layers[i].minscale); 
    2032           if(nVersion >= OWS_1_1_0 && map->layers[i].maxscale > 0) 
     2031                           GET_LAYER(map, i)->minscale); 
     2032          if(nVersion >= OWS_1_1_0 && GET_LAYER(map, i)->maxscale > 0) 
    20332033              msIO_fprintf(stream,  
    20342034               "      <sld:MaxScaleDenominator>%g</sld:MaxScaleDenominator>\n", 
    2035                            map->layers[i].maxscale); 
     2035                           GET_LAYER(map, i)->maxscale); 
    20362036 
    20372037          /* Layer SRS */ 
    2038           pszValue = (char*)msOWSGetEPSGProj(&(map->layers[i].projection),  
    2039                                              &(map->layers[i].metadata), 
     2038          pszValue = (char*)msOWSGetEPSGProj(&(GET_LAYER(map, i)->projection),  
     2039                                             &(GET_LAYER(map, i)->metadata), 
    20402040                                             "MO", MS_FALSE); 
    20412041          if(pszValue && (strcasecmp(pszValue, "(null)") != 0)) 
    20422042          { 
     
    20462046          } 
    20472047 
    20482048          /* Format */ 
    2049           if(msLookupHashTable(&(map->layers[i].metadata),"wms_formatlist")==NULL &&  
    2050              msLookupHashTable(&(map->layers[i].metadata),"wms_format")==NULL) 
     2049          if(msLookupHashTable(&(GET_LAYER(map, i)->metadata),"wms_formatlist")==NULL &&  
     2050             msLookupHashTable(&(GET_LAYER(map, i)->metadata),"wms_format")==NULL) 
    20512051          { 
    20522052              pszURL = NULL; 
    2053               if(map->layers[i].connection) 
    2054                   pszURL = strdup( map->layers[i].connection ); 
     2053              if(GET_LAYER(map, i)->connection) 
     2054                  pszURL = strdup( GET_LAYER(map, i)->connection ); 
    20552055              else 
    20562056                  pszURL = strdup( "" ); 
    20572057              pszValue = pszURL; 
     
    20792079              char **papszFormats; 
    20802080              int numFormats, nForm; 
    20812081 
    2082               pszValue = msLookupHashTable(&(map->layers[i].metadata),  
     2082              pszValue = msLookupHashTable(&(GET_LAYER(map, i)->metadata),  
    20832083                                           "wms_formatlist"); 
    20842084              if(!pszValue) 
    2085                   pszValue = msLookupHashTable(&(map->layers[i].metadata),  
     2085                  pszValue = msLookupHashTable(&(GET_LAYER(map, i)->metadata),  
    20862086                                               "wms_format"); 
    2087               pszCurrent = msLookupHashTable(&(map->layers[i].metadata),  
     2087              pszCurrent = msLookupHashTable(&(GET_LAYER(map, i)->metadata),  
    20882088                                             "wms_format"); 
    20892089 
    20902090              papszFormats = split(pszValue, ',', &numFormats); 
     
    21112111          } 
    21122112          /* Style */ 
    21132113          /* First check the stylelist */ 
    2114           pszValue = msLookupHashTable(&(map->layers[i].metadata),  
     2114          pszValue = msLookupHashTable(&(GET_LAYER(map, i)->metadata),  
    21152115                                       "wms_stylelist"); 
    21162116          if(pszValue == NULL || strlen(trimLeft(pszValue)) < 1) 
    21172117          { 
    21182118              /* Check if the style is in the connection URL */ 
    21192119              pszURL = ""; 
    2120               if(map->layers[i].connection) 
    2121                   pszURL = strdup( map->layers[i].connection ); 
     2120              if(GET_LAYER(map, i)->connection) 
     2121                  pszURL = strdup( GET_LAYER(map, i)->connection ); 
    21222122              else 
    21232123                  pszURL = strdup( "" ); 
    21242124              pszValue = pszURL; 
     
    21322132                      pszValue[pszChar - pszValue] = '\0'; 
    21332133 
    21342134                  /* Check the SLD string from the URL */ 
    2135                   if(map->layers[i].connection) 
    2136                       pszSLD2 = strdup(map->layers[i].connection); 
     2135                  if(GET_LAYER(map, i)->connection) 
     2136                      pszSLD2 = strdup(GET_LAYER(map, i)->connection); 
    21372137                  else 
    21382138                      pszSLD2 = strdup( "" ); 
    21392139                  if(pszSLD2) 
     
    22152215          { 
    22162216              /* If the style information is not in the connection URL, */ 
    22172217              /* read the metadata. */ 
    2218               pszValue = msLookupHashTable(&(map->layers[i].metadata),  
     2218              pszValue = msLookupHashTable(&(GET_LAYER(map, i)->metadata),  
    22192219                                           "wms_stylelist"); 
    2220               pszCurrent = msLookupHashTable(&(map->layers[i].metadata),  
     2220              pszCurrent = msLookupHashTable(&(GET_LAYER(map, i)->metadata),  
    22212221                                             "wms_style"); 
    22222222              msIO_fprintf( stream, "      <StyleList>\n"); 
    22232223              /* Loop in each style in the style list */ 
     
    22382238                  /* Write SLDURL if it is in the metadata */ 
    22392239                  pszStyleItem = (char*)malloc(strlen(pszStyle)+10+10); 
    22402240                  sprintf(pszStyleItem, "wms_style_%s_sld", pszStyle); 
    2241                   if(msLookupHashTable(&(map->layers[i].metadata), 
     2241                  if(msLookupHashTable(&(GET_LAYER(map, i)->metadata), 
    22422242                                       pszStyleItem) != NULL) 
    22432243                  { 
    22442244                      msIO_fprintf(stream, "          <SLD>\n"); 
    22452245                      msOWSPrintEncodeMetadata(stream,  
    2246                                                &(map->layers[i].metadata), 
     2246                                               &(GET_LAYER(map, i)->metadata), 
    22472247                                               NULL, pszStyleItem,  
    22482248                                               OWS_NOERR,  
    22492249     "            <OnlineResource xlink:type=\"simple\" xlink:href=\"%s\"/>\n", 
     
    22552255                  { 
    22562256                      /* If the URL is not there, check for SLDBody */ 
    22572257                      sprintf(pszStyleItem, "wms_style_%s_sld_body", pszStyle); 
    2258                       if(msLookupHashTable(&(map->layers[i].metadata), 
     2258                      if(msLookupHashTable(&(GET_LAYER(map, i)->metadata), 
    22592259                                           pszStyleItem) != NULL) 
    22602260                      { 
    22612261                          msIO_fprintf(stream, "          <SLD>\n"); 
    2262                           msOWSPrintMetadata(stream,&(map->layers[i].metadata), 
     2262                          msOWSPrintMetadata(stream,&(GET_LAYER(map, i)->metadata), 
    22632263                                             NULL, pszStyleItem, OWS_NOERR,  
    22642264                                             "            %s\n", NULL); 
    22652265                          msIO_fprintf(stream, "          </SLD>\n"); 
     
    22792279                          sprintf(pszStyleItem, "wms_style_%s_title",pszStyle); 
    22802280                          /* Title */ 
    22812281                          msOWSPrintEncodeMetadata(stream,  
    2282                                                    &(map->layers[i].metadata),  
     2282                                                   &(GET_LAYER(map, i)->metadata),  
    22832283                                                   NULL, pszStyleItem,  
    22842284                                                   OWS_NOERR,  
    22852285                                        "          <Title>%s</Title>\n", 
     
    22902290                          pszStyleItem = (char*)malloc(strlen(pszStyle)+10+20); 
    22912291                          sprintf(pszStyleItem, "style_%s_legendurl", 
    22922292                                  pszStyle); 
    2293                           msOWSPrintURLType(stream, &(map->layers[i].metadata), 
     2293                          msOWSPrintURLType(stream, &(GET_LAYER(map, i)->metadata), 
    22942294                                            "M", pszStyleItem, OWS_NOERR, NULL, 
    22952295                                            "LegendURL", NULL, " width=\"%s\"", 
    22962296                                            " height=\"%s\""," format=\"%s\"", 
     
    23172317          /* Dimension element */; 
    23182318          pszCurrent = NULL; 
    23192319 
    2320           pszValue = msLookupHashTable(&(map->layers[i].metadata),  
     2320          pszValue = msLookupHashTable(&(GET_LAYER(map, i)->metadata),  
    23212321                                       "wms_dimensionlist"); 
    2322           pszCurrent = msLookupHashTable(&(map->layers[i].metadata),  
     2322          pszCurrent = msLookupHashTable(&(GET_LAYER(map, i)->metadata),  
    23232323                                         "wms_dimension"); 
    23242324          while(pszValue != NULL) 
    23252325          { 
     
    23382338              } 
    23392339 
    23402340              /* From the dimension list, extract the required dimension */ 
    2341               msOWSGetDimensionInfo(&(map->layers[i]), pszDimension,  
     2341              msOWSGetDimensionInfo(&(GET_LAYER(map, i)), pszDimension,  
    23422342                                    &pszDimUserValue, &pszDimUnits,  
    23432343                                    &pszDimDefault, &pszDimNearValue,  
    23442344                                    &pszDimUnitSymbol, &pszDimMultiValue); 
  • mapcopy.c

    old new  
    878878    MS_COPYSTELEM(numlayers); 
    879879 
    880880    for (i = 0; i < dst->numlayers; i++) { 
    881         initLayer(&(dst->layers[i]), dst); 
     881        initLayer((GET_LAYER(dst, i)), dst); 
    882882 
    883         return_value = msCopyLayer(&(dst->layers[i]), &(src->layers[i])); 
     883        return_value = msCopyLayer((GET_LAYER(dst, i)), (GET_LAYER(src, i))); 
    884884        if (return_value != MS_SUCCESS) { 
    885885            msSetError(MS_MEMERR, "Failed to copy layer.", "msCopyMap()"); 
    886886            return MS_FAILURE; 
  • mapdraw.c

    old new  
    217217  int i; 
    218218 
    219219  for(i=0; i<map->numlayers; i++) 
    220     msClearLayerPenValues(&(map->layers[i])); 
     220    msClearLayerPenValues((GET_LAYER(map, i))); 
    221221 
    222222  msClearLegendPenValues(&(map->legend)); 
    223223  msClearScalebarPenValues(&(map->scalebar)); 
     
    360360 
    361361    /* compute layer scale factors now */ 
    362362    for(i=0;i<map->numlayers; i++) { 
    363       if(map->layers[i].sizeunits != MS_PIXELS) 
    364         map->layers[i].scalefactor = (msInchesPerUnit(map->layers[i].sizeunits,0)/msInchesPerUnit(map->units,0)) / geo_cellsize; 
    365       else if(map->layers[i].symbolscale > 0 && map->scale > 0) 
    366         map->layers[i].scalefactor = map->layers[i].symbolscale/map->scale; 
     363      if(GET_LAYER(map, i)->sizeunits != MS_PIXELS) 
     364        GET_LAYER(map, i)->scalefactor = (msInchesPerUnit(GET_LAYER(map, i)->sizeunits,0)/msInchesPerUnit(map->units,0)) / geo_cellsize; 
     365      else if(GET_LAYER(map, i)->symbolscale > 0 && map->scale > 0) 
     366        GET_LAYER(map, i)->scalefactor = GET_LAYER(map, i)->symbolscale/map->scale; 
    367367      else 
    368         map->layers[i].scalefactor = 1; 
     368        GET_LAYER(map, i)->scalefactor = 1; 
    369369    } 
    370370 
    371371    return image; 
     
    421421    for(i=0; i<map->numlayers; i++)  
    422422    { 
    423423        if (map->layerorder[i] == -1 ||  
    424             !msLayerIsVisible(map, &(map->layers[map->layerorder[i]]))) 
     424            !msLayerIsVisible(map, &(GET_LAYER(map, map->layerorder[i])))) 
    425425            continue; 
    426426 
    427         lp = &(map->layers[ map->layerorder[i]]); 
     427        lp = &(GET_LAYER(map,  map->layerorder[i])); 
    428428 
    429429#ifdef USE_WMS_LYR 
    430430        if (lp->connectiontype == MS_WMS) 
     
    473473    for(i=0; i<map->numlayers; i++) { 
    474474 
    475475        if (map->layerorder[i] != -1) { 
    476             lp = &(map->layers[ map->layerorder[i]]); 
     476            lp = (GET_LAYER(map,  map->layerorder[i])); 
    477477 
    478478            if(lp->postlabelcache) /* wait to draw */ 
    479479                continue; 
     
    602602 
    603603  for(i=0; i<map->numlayers; i++) { /* for each layer, check for postlabelcache layers */ 
    604604 
    605     lp = &(map->layers[map->layerorder[i]]); 
     605    lp = (GET_LAYER(map, map->layerorder[i])); 
    606606 
    607607    if(!lp->postlabelcache) 
    608608      continue; 
     
    734734 
    735735  /* compute layer scale factors now */ 
    736736  for(i=0;i<map->numlayers; i++) { 
    737     if(map->layers[i].sizeunits != MS_PIXELS) 
    738       map->layers[i].scalefactor = (msInchesPerUnit(map->layers[i].sizeunits,0)/msInchesPerUnit(map->units,0)) / map->cellsize;  
    739     else if(map->layers[i].symbolscale > 0 && map->scale > 0) 
    740       map->layers[i].scalefactor = map->layers[i].symbolscale/map->scale; 
     737    if(GET_LAYER(map, i)->sizeunits != MS_PIXELS) 
     738      GET_LAYER(map, i)->scalefactor = (msInchesPerUnit(GET_LAYER(map, i)->sizeunits,0)/msInchesPerUnit(map->units,0)) / map->cellsize;  
     739    else if(GET_LAYER(map, i)->symbolscale > 0 && map->scale > 0) 
     740      GET_LAYER(map, i)->scalefactor = GET_LAYER(map, i)->symbolscale/map->scale; 
    741741    else 
    742       map->layers[i].scalefactor = 1; 
     742      GET_LAYER(map, i)->scalefactor = 1; 
    743743  } 
    744744 
    745745  for(i=0; i<map->numlayers; i++) { 
    746     lp = &(map->layers[ map->layerorder[i]]); 
     746    lp = (GET_LAYER(map,  map->layerorder[i])); 
    747747 
    748748    if(lp->postlabelcache) /* wait to draw */ 
    749749      continue; 
     
    762762    return(NULL); 
    763763 
    764764  for(i=0; i<map->numlayers; i++) { /* for each layer, check for postlabelcache layers */ 
    765     lp = &(map->layers[ map->layerorder[i]]); 
     765    lp = (GET_LAYER(map,  map->layerorder[i])); 
    766766 
    767767    if(!lp->postlabelcache) 
    768768      continue; 
  • maperror.h

    old new  
    9696#define MS_TIMEERR 35 
    9797#define MS_GMLERR 36 
    9898#define MS_SOSERR 37 
    99 #define MS_NUMERRORCODES 38 
     99#define MS_NULLPARENTERR 38 
     100#define MS_NUMERRORCODES 39 
    100101 
    101102#define MESSAGELENGTH 2048 
    102103#define ROUTINELENGTH 64 
  • mapfile.c

    old new  
    471471  if(!name) return(-1); 
    472472 
    473473  for(i=0;i<map->numlayers; i++) { 
    474     if(!map->layers[i].name) /* skip it */ 
     474    if(!GET_LAYER(map, i)->name) /* skip it */ 
    475475      continue; 
    476     if(strcmp(name, map->layers[i].name) == 0) 
     476    if(strcmp(name, GET_LAYER(map, i)->name) == 0) 
    477477      return(i); 
    478478  } 
    479479  return(-1); 
     
    24402440*/ 
    24412441int initLayer(layerObj *layer, mapObj *map) 
    24422442{ 
     2443  if (layer==NULL) { 
     2444    msSetError(MS_MEMERR, "Layer is null", "initLayer()"); 
     2445    return(-1); 
     2446  } 
    24432447  layer->debug = MS_OFF; 
     2448  MS_REFCNT_INIT(layer); 
    24442449 
    24452450  layer->numclasses = 0; 
    24462451  if((layer->class = (classObj *)malloc(sizeof(classObj)*MS_MAXCLASSES)) == NULL) { 
     
    25502555  return(0); 
    25512556} 
    25522557 
    2553 void freeLayer(layerObj *layer) { 
     2558int freeLayer(layerObj *layer) { 
    25542559  int i; 
     2560  if (!layer) return MS_FAILURE; 
     2561  if( MS_REFCNT_IS_NOT_ZERO(layer) ) { return MS_FAILURE; } 
     2562  if (layer->debug) 
     2563     msDebug("freeLayer(): freeing layer at %p.",layer); 
    25552564 
    25562565  msFree(layer->name); 
    25572566  msFree(layer->group); 
     
    25712580  msFree(layer->connection); 
    25722581  msFree(layer->vtable); 
    25732582 
    2574  
    25752583  msFreeProjection(&(layer->projection)); 
    25762584 
    25772585  for(i=0;i<layer->numclasses;i++) 
     
    26012609    freeJoin(&(layer->joins[i])); 
    26022610  msFree(layer->joins); 
    26032611  layer->numjoins = 0; 
     2612 
     2613  return MS_SUCCESS; 
    26042614} 
    26052615 
    26062616int loadLayer(layerObj *layer, mapObj *map) 
     
    43364346*/ 
    43374347int initMap(mapObj *map) 
    43384348{ 
     4349  int i=0; 
     4350  MS_REFCNT_INIT(map); 
    43394351  map->numlayers = 0; 
    4340   if((map->layers = (layerObj *)malloc(sizeof(layerObj)*MS_MAXLAYERS)) == NULL) { 
     4352  if((map->layers = (layerObj **)malloc(sizeof(layerObj*)*MS_MAXLAYERS)) == NULL) { 
    43414353    msSetError(MS_MEMERR, NULL, "initMap()"); 
    43424354    return(-1); 
    43434355  } 
     4356  for (i=0;i<MS_MAXLAYERS;i++) { 
     4357        map->layers[i]=NULL; 
     4358  } 
    43444359 
    43454360  map->debug = MS_OFF; 
    43464361  map->status = MS_ON; 
     
    45534568 
    45544569  for(i=0; i<map->numlayers; i++) 
    45554570  { 
    4556       writeLayer(&(map->layers[map->layerorder[i]]), stream); 
    4557       /* writeLayer(&(map->layers[i]), stream); */ 
     4571      writeLayer((GET_LAYER(map, map->layerorder[i])), stream); 
     4572      /* writeLayer(&(GET_LAYER(map, i)), stream); */ 
    45584573  } 
    45594574 
    45604575  fprintf(stream, "END\n"); 
     
    46604675 
    46614676      /* step through layers and classes to resolve symbol names */ 
    46624677      for(i=0; i<map->numlayers; i++) { 
    4663         for(j=0; j<map->layers[i].numclasses; j++){ 
    4664           for(k=0; k<map->layers[i].class[j].numstyles; k++) { 
    4665             if(map->layers[i].class[j].styles[k].symbolname) { 
    4666               if((map->layers[i].class[j].styles[k].symbol =  msGetSymbolIndex(&(map->symbolset), map->layers[i].class[j].styles[k].symbolname, MS_TRUE)) == -1) { 
    4667                 msSetError(MS_MISCERR, "Undefined overlay symbol \"%s\" in class %d, style %d of layer %s.", "msLoadMap()", map->layers[i].class[j].styles[k].symbolname, j, k, map->layers[i].name); 
     4678        for(j=0; j<GET_LAYER(map, i)->numclasses; j++){ 
     4679          for(k=0; k<GET_LAYER(map, i)->class[j].numstyles; k++) { 
     4680            if(GET_LAYER(map, i)->class[j].styles[k].symbolname) { 
     4681              if((GET_LAYER(map, i)->class[j].styles[k].symbol =  msGetSymbolIndex(&(map->symbolset), GET_LAYER(map, i)->class[j].styles[k].symbolname, MS_TRUE)) == -1) { 
     4682                msSetError(MS_MISCERR, "Undefined overlay symbol \"%s\" in class %d, style %d of layer %s.", "msLoadMap()", GET_LAYER(map, i)->class[j].styles[k].symbolname, j, k, GET_LAYER(map, i)->name); 
    46684683                return(NULL); 
    46694684              } 
    46704685            } 
     
    47304745            msSetError(MS_IDENTERR, "Maximum number of layers reached.", "msLoadMap()"); 
    47314746            return(NULL); 
    47324747      } 
    4733       if(loadLayer(&(map->layers[map->numlayers]), map) == -1) return(NULL); 
    4734       map->layers[map->numlayers].index = map->numlayers; /* save the index */ 
     4748      //printf("New layer=%d %p\n",map->numlayers,map->layers[map->numlayers]); 
     4749      map->layers[map->numlayers]=(layerObj*)malloc(sizeof(layerObj)); 
     4750      //printf("After new layer=%d %p\n",map->numlayers,map->layers[map->numlayers]); 
     4751      if (GET_LAYER(map, map->numlayers) == NULL) { 
     4752           msSetError(MS_MEMERR, "Malloc of a new layer failed.", "msLoadMap()"); 
     4753           return(NULL); 
     4754      } 
     4755      if(loadLayer((GET_LAYER(map, map->numlayers)), map) == -1) return(NULL); 
     4756      GET_LAYER(map, map->numlayers)->index = map->numlayers; /* save the index */ 
    47354757      /* Update the layer order list with the layer's index. */ 
    47364758      map->layerorder[map->numlayers] = map->numlayers; 
    47374759      map->numlayers++; 
     
    49174939    case(LAYER):       
    49184940      if(getInteger(&i) == -1) break; 
    49194941      if(i>=map->numlayers || i<0) break; 
    4920       loadLayerString(map, &(map->layers[i]), value); 
     4942      loadLayerString(map, (GET_LAYER(map, i)), value); 
    49214943      break; 
    49224944    case(LEGEND): 
    49234945      loadLegendString(map, &(map->legend), value); 
     
    49624984    case(MS_STRING): 
    49634985      i = msGetLayerIndex(map, msyytext); 
    49644986      if(i>=map->numlayers || i<0) break; 
    4965       loadLayerString(map, &(map->layers[i]), value); 
     4987      loadLayerString(map, (GET_LAYER(map, i)), value); 
    49664988      break; 
    49674989    case(TRANSPARENT): 
    49684990      msyystate = 2; msyystring = value; 
     
    51145136  layerObj *lp; 
    51155137 
    51165138  for (i=0;i<map->numlayers;i++) { 
    5117     lp = &(map->layers[i]); 
     5139    lp = (GET_LAYER(map, i)); 
    51185140 
    51195141    /* If the vtable is null, then the layer is never accessed or used -> skip it 
    51205142     */ 
  • mapgd.c

    old new  
    184184  if(gdImageTrueColor(image->img.gd)) return; 
    185185 
    186186  for(i=0; i<map->numlayers; i++) { 
    187     lp = &(map->layers[i]); 
     187    lp = (GET_LAYER(map, i)); 
    188188    if(lp->status == MS_ON || lp->status == MS_DEFAULT) { 
    189189      for(j=0; j<lp->numclasses; j++) { 
    190190        cp = &(lp->class[j]); 
     
    32493249 
    32503250    cachePtr = &(map->labelcache.labels[l]); /* point to right spot in the label cache */ 
    32513251 
    3252     layerPtr = &(map->layers[cachePtr->layerindex]); /* set a couple of other pointers, avoids nasty references */ 
     3252    layerPtr = (GET_LAYER(map, cachePtr->layerindex)); /* set a couple of other pointers, avoids nasty references */ 
    32533253    labelPtr = &(cachePtr->label); 
    32543254 
    32553255    if(!cachePtr->text || strlen(cachePtr->text) == 0) 
  • mapgml.c

    old new  
    14241424 
    14251425  /* step through the layers looking for query results */ 
    14261426  for(i=0; i<map->numlayers; i++) { 
    1427     lp = &(map->layers[map->layerorder[i]]); 
     1427    lp = (GET_LAYER(map, map->layerorder[i])); 
    14281428 
    14291429    if(lp->dump == MS_TRUE && lp->resultcache && lp->resultcache->numresults > 0) { /* found results */ 
    14301430 
     
    15751575  /* step through the layers looking for query results */ 
    15761576  for(i=0; i<map->numlayers; i++) { 
    15771577 
    1578     lp = &(map->layers[map->layerorder[i]]); 
     1578    lp = &(GET_LAYER(map, map->layerorder[i])); 
    15791579 
    15801580    if(lp->dump == MS_TRUE && lp->resultcache && lp->resultcache->numresults > 0)  { /* found results */ 
    15811581      char *layerName;       
  • mapgraticule.c

    old new  
    200200        int                                      iAxisTickCount = 0; 
    201201        rectObj                          rectMapCoordinates; 
    202202 
     203        if ( msCheckParentPointer(layer->map,"map")==MS_FAILURE ) 
     204                return MS_FAILURE; 
     205 
    203206        pInfo->dstartlatitude                   = rect.miny; 
    204207        pInfo->dstartlongitude                  = rect.minx; 
    205208        pInfo->dendlatitude                             = rect.maxy; 
     
    686689        msSetError(MS_MISCERR, "Assertion failed: Null shape or layerinfo!, ", "_AdjustLabelPosition()"); 
    687690                return MS_FAILURE; 
    688691    } 
     692        if ( msCheckParentPointer(pLayer->map,"map")==MS_FAILURE ) 
     693                return MS_FAILURE; 
    689694         
    690695        ptPoint                 = pShape->line->point[0]; 
    691696 
  • map.h

    old new  
    403403 
    404404#define MS_ENCRYPTION_KEY_SIZE  16   /* Key size: 128 bits = 16 bytes */ 
    405405 
     406#define GET_LAYER(map, pos) map->layers[pos] 
     407#define MS_REFCNT_INCR(obj) obj->refcount++ 
     408#define MS_REFCNT_DECR(obj) obj->refcount-- 
     409#define MS_REFCNT_INIT(obj) obj->refcount=1 
     410#define MS_REFCNT_IS_NOT_ZERO(obj) (MS_REFCNT_DECR(obj))>0 
     411#define MS_REFCNT_IS_ZERO(obj) (MS_REFCNT_DECR(obj))<=0 
     412 
    406413#endif 
    407414 
    408415/* General enumerated types - needed by scripts */ 
     
    9951002#ifdef SWIG 
    9961003%immutable; 
    9971004#endif /* SWIG */ 
     1005  /* reference counting, RFC24 */ 
     1006  int refcount; 
    9981007  int numclasses; 
    9991008  int index; 
    10001009  struct map_obj *map; 
     
    11331142  int maxsize; 
    11341143 
    11351144#ifndef SWIG 
    1136   layerObj *layers; 
     1145  layerObj **layers; 
    11371146#endif /* SWIG */ 
    11381147 
    11391148#ifdef SWIG 
    11401149%immutable; 
    11411150#endif /* SWIG */ 
     1151  /* reference counting, RFC24 */ 
     1152  int refcount; 
    11421153  int numlayers; /* number of layers in mapfile */ 
    11431154 
    11441155  symbolSetObj symbolset; 
     
    13461357MS_DLL_EXPORT void initSymbol(symbolObj *s); 
    13471358MS_DLL_EXPORT int initMap(mapObj *map); 
    13481359MS_DLL_EXPORT int initLayer(layerObj *layer, mapObj *map); 
    1349 MS_DLL_EXPORT void freeLayer( layerObj * ); 
     1360MS_DLL_EXPORT int freeLayer( layerObj * ); 
    13501361MS_DLL_EXPORT int initClass(classObj *_class); 
    13511362MS_DLL_EXPORT void freeClass( classObj * ); 
    13521363MS_DLL_EXPORT void initLabel(labelObj *label); 
     
    18531864 
    18541865MS_DLL_EXPORT int msAlphaBlend (int dst, int src); 
    18551866 
     1867MS_DLL_EXPORT int msCheckParentPointer(void* p, char* objname); 
     1868 
    18561869 
    18571870/* ==================================================================== */ 
    18581871/*      End of prototypes for functions in maputil.c                    */ 
  • mapimagemap.c

    old new  
    18771877 
    18781878    cachePtr = &(map->labelcache.labels[l]); /* point to right spot in the label cache */ 
    18791879 
    1880     layerPtr = &(map->layers[cachePtr->layerindex]); /* set a couple of other pointers, avoids nasty references */ 
     1880    layerPtr = (GET_LAYER(map, cachePtr->layerindex)); /* set a couple of other pointers, avoids nasty references */ 
    18811881    labelPtr = &(cachePtr->label); 
    18821882 
    18831883    if(!cachePtr->text || strlen(cachePtr->text) == 0) 
  • mapjoin.c

    old new  
    188188  msDBFJoinInfo *joininfo; 
    189189 
    190190  if(join->joininfo) return(MS_SUCCESS); /* already open */ 
     191   
     192  if ( msCheckParentPointer(layer->map,"map")==MS_FAILURE ) 
     193        return MS_FAILURE; 
     194   
    191195     
    192196  /* allocate a msDBFJoinInfo struct */ 
    193197  joininfo = (msDBFJoinInfo *) malloc(sizeof(msDBFJoinInfo)); 
     
    345349  char buffer[MS_BUFFER_LENGTH]; 
    346350 
    347351  if(join->joininfo) return(MS_SUCCESS); /* already open */ 
     352  if ( msCheckParentPointer(layer->map,"map")==MS_FAILURE ) 
     353        return MS_FAILURE; 
     354   
    348355     
    349356  /* allocate a msCSVJoinInfo struct */ 
    350357  if((joininfo = (msCSVJoinInfo *) malloc(sizeof(msCSVJoinInfo))) == NULL) { 
  • maplabel.c

    old new  
    105105  } 
    106106 
    107107  cachePtr = &(map->labelcache.labels[map->labelcache.numlabels]); /* set up a few pointers for clarity */ 
    108   layerPtr = &(map->layers[layerindex]); 
    109   classPtr = &(map->layers[layerindex].class[classindex]); 
     108  layerPtr = (GET_LAYER(map, layerindex)); 
     109  classPtr = &(GET_LAYER(map, layerindex)->class[classindex]); 
    110110 
    111111  if( label == NULL ) 
    112112      label = &(classPtr->label); 
  • maplegend.c

    old new  
    289289  ** allocate heights array 
    290290  */ 
    291291  for(i=0; i<map->numlayers; i++) { 
    292     lp = &(map->layers[map->layerorder[i]]); 
     292    lp = (GET_LAYER(map, map->layerorder[i])); 
    293293 
    294294    if((lp->status == MS_OFF) || (lp->type == MS_LAYER_QUERY)) /* skip it */ 
    295295      continue; 
     
    310310  */ 
    311311  n=0; 
    312312  for(i=0; i<map->numlayers; i++) { /* Need to find the longest legend label string */ 
    313     lp = &(map->layers[map->layerorder[i]]); 
     313    lp = (GET_LAYER(map, map->layerorder[i])); 
    314314 
    315315    if((lp->status == MS_OFF) || (lp->type == MS_LAYER_QUERY)) /* skip it */ 
    316316      continue; 
     
    375375     
    376376  /* for(i=0; i<map->numlayers; i++) { */ 
    377377  for(i=map->numlayers-1; i>=0; i--) { 
    378     lp = &(map->layers[map->layerorder[i]]); /* for brevity */ 
     378    lp = (GET_LAYER(map, map->layerorder[i])); /* for brevity */ 
    379379 
    380380    if((lp->numclasses == 0) || (lp->status == MS_OFF) || (lp->type == MS_LAYER_QUERY)) 
    381381      continue; /* skip this layer */ 
     
    490490    l = map->numlayers; 
    491491    map->numlayers++; 
    492492 
    493     if(initLayer(&(map->layers[l]), map) == -1) return(-1); 
    494     map->layers[l].name = strdup("__embed__legend"); 
    495     map->layers[l].type = MS_LAYER_ANNOTATION; 
     493    if(initLayer((GET_LAYER(map, l)), map) == -1) return(-1); 
     494    GET_LAYER(map, l)->name = strdup("__embed__legend"); 
     495    GET_LAYER(map, l)->type = MS_LAYER_ANNOTATION; 
    496496 
    497     if(initClass(&(map->layers[l].class[0])) == -1) return(-1); 
    498     map->layers[l].numclasses = 1; /* so we make sure to free it */ 
     497    if(initClass(&(GET_LAYER(map, l)->class[0])) == -1) return(-1); 
     498    GET_LAYER(map, l)->numclasses = 1; /* so we make sure to free it */ 
    499499         
    500500    /* update the layer order list with the layer's index. */ 
    501501    map->layerorder[l] = l; 
    502502  } 
    503503 
    504   map->layers[l].status = MS_ON; 
     504  GET_LAYER(map, l)->status = MS_ON; 
    505505 
    506   map->layers[l].class[0].numstyles = 1; 
    507   map->layers[l].class[0].styles[0].symbol = s; 
    508   map->layers[l].class[0].styles[0].color.pen = -1; 
    509   map->layers[l].class[0].label.force = MS_TRUE; 
    510   map->layers[l].class[0].label.size = MS_MEDIUM; /* must set a size to have a valid label definition */ 
     506  GET_LAYER(map, l)->class[0].numstyles = 1; 
     507  GET_LAYER(map, l)->class[0].styles[0].symbol = s; 
     508  GET_LAYER(map, l)->class[0].styles[0].color.pen = -1; 
     509  GET_LAYER(map, l)->class[0].label.force = MS_TRUE; 
     510  GET_LAYER(map, l)->class[0].label.size = MS_MEDIUM; /* must set a size to have a valid label definition */ 
    511511 
    512512  if(map->legend.postlabelcache) /* add it directly to the image */ 
    513     msDrawMarkerSymbolGD(&map->symbolset, img, &point, &(map->layers[l].class[0].styles[0]), 1.0); 
     513    msDrawMarkerSymbolGD(&map->symbolset, img, &point, &(GET_LAYER(map, l)->class[0].styles[0]), 1.0); 
    514514  else 
    515515    msAddLabel(map, l, 0, -1, -1, &point, NULL, " ", 1.0, NULL); 
    516516 
    517517  /* Mark layer as deleted so that it doesn't interfere with html legends or */ 
    518518  /* with saving maps */ 
    519   map->layers[l].status = MS_DELETE; 
     519  GET_LAYER(map, l)->status = MS_DELETE; 
    520520 
    521521  return(0); 
    522522} 
  • mapmygis.c

    old new  
    341341 
    342342  /* TODO: there is an issue with layer order since it's possible that layers to be rendered out of order */ 
    343343  for (i=0;i<layer->index;i++) {        /* check all layers previous to this one */ 
    344     lp = &(layer->map->layers[i]); 
     344    lp = &(GET_LAYER(layer->map, i)); 
    345345 
    346346    if (lp == layer) continue; 
    347347 
  • mapobject.c

    old new  
    169169  int i; 
    170170 
    171171  if(!map) return; 
     172 
     173  if ( MS_REFCNT_IS_NOT_ZERO(map) ) { return; } 
     174  if (map->debug) 
     175     msDebug("msFreeMap(): freeing map at %p.",map); 
     176   
    172177  msCloseConnections(map); 
    173178 
    174179  msFree(map->name); 
     
    203208  freeReferenceMap(&(map->reference)); 
    204209  freeLegend(&(map->legend));   
    205210 
    206   for(i=0; i<map->numlayers; i++) 
    207     freeLayer(&(map->layers[i])); 
     211  //for(i=0; i<map->numlayers; i++) 
     212  for(i=0; i<MS_MAXLAYERS; i++) { 
     213    if (GET_LAYER(map, i)!=NULL) { 
     214        GET_LAYER(map, i)->map=NULL; 
     215        if ( freeLayer((GET_LAYER(map, i))) == MS_SUCCESS) { 
     216                free(GET_LAYER(map, i)); 
     217        } 
     218    } 
     219  } 
    208220  msFree(map->layers); 
    209221 
    210222  if (map->layerorder) 
     
    475487    map->projection.gt.geotransform[5] *= -1; 
    476488 
    477489    for(i=0; i<map->numlayers; i++) 
    478         map->layers[i].project = MS_TRUE; 
     490        GET_LAYER(map, i)->project = MS_TRUE; 
    479491 
    480492    return InvGeoTransform( map->projection.gt.geotransform,  
    481493                            map->projection.gt.invgeotransform ); 
     
    524536        return -1; 
    525537    } 
    526538    else if (nIndex < 0) { /* Insert at the end by default */ 
    527         initLayer(&(map->layers[map->numlayers]), map); 
    528         msCopyLayer(&(map->layers[map->numlayers]), layer); 
     539        //initLayer((GET_LAYER(map, map->numlayers)), map); 
     540        //msCopyLayer((GET_LAYER(map, map->numlayers)), layer); 
    529541        map->layerorder[map->numlayers] = map->numlayers; 
    530         map->layers[map->numlayers].index = map->numlayers; 
     542        GET_LAYER(map, map->numlayers) = layer; 
     543        GET_LAYER(map, map->numlayers)->index = map->numlayers; 
     544        MS_REFCNT_INCR(layer); 
    531545        map->numlayers++; 
    532546        return map->numlayers-1; 
    533547    } 
     
    536550