Skip to content

Commit 420dcb1

Browse files
rouaultrouault
committed
msSLDApplySLD(): tidy-up code. No functional change
1 parent 346c167 commit 420dcb1

1 file changed

Lines changed: 112 additions & 104 deletions

File tree

‎mapogcsld.c‎

Lines changed: 112 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -151,23 +151,13 @@ int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer, const char *psz
151151

152152
#ifdef USE_OGR
153153

154-
int nLayers = 0;
155-
layerObj *pasLayers = NULL;
156-
int i, j, k, z, iClass;
157-
int bUseSpecificLayer = 0;
158-
const char *pszTmp = NULL;
154+
int nSLDLayers = 0;
155+
layerObj *pasSLDLayers = NULL;
159156
int nStatus = MS_SUCCESS;
160157
/*const char *pszSLDNotSupported = NULL;*/
161-
char *tmpfilename = NULL;
162-
const char *pszFullName = NULL;
163-
char szTmp[512];
164-
char *pszTmp1=NULL;
165-
char *pszTmp2 = NULL;
166-
char *pszBuffer = NULL;
167-
layerObj *lp = NULL;
168-
169-
pasLayers = msSLDParseSLD(map, psSLDXML, &nLayers);
170-
if( pasLayers == NULL ) {
158+
159+
pasSLDLayers = msSLDParseSLD(map, psSLDXML, &nSLDLayers);
160+
if( pasSLDLayers == NULL ) {
171161
errorObj* psError = msGetErrorObj();
172162
if( psError && psError->code != MS_NOERR )
173163
return MS_FAILURE;
@@ -177,20 +167,22 @@ int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer, const char *psz
177167
/* If the same layer is given more that once, we need to */
178168
/* duplicate it. */
179169
/* -------------------------------------------------------------------- */
180-
if (pasLayers && nLayers>0) {
181-
int l,m;
182-
for (m=0; m<nLayers; m++) {
170+
if (pasSLDLayers && nSLDLayers>0) {
171+
int i;
172+
int m;
173+
for (m=0; m<nSLDLayers; m++) {
174+
int l;
183175
layerObj *psTmpLayer=NULL;
184176
int nIndex;
185177
char tmpId[128];
186-
nIndex = msGetLayerIndex(map, pasLayers[m].name);
187-
if(pasLayers[m].name == NULL) continue;
188-
for (l=0; l<nLayers; l++) {
189-
if(pasLayers[l].name == NULL)
178+
nIndex = msGetLayerIndex(map, pasSLDLayers[m].name);
179+
if(pasSLDLayers[m].name == NULL) continue;
180+
for (l=0; l<nSLDLayers; l++) {
181+
if(pasSLDLayers[l].name == NULL)
190182
continue;
191183

192184

193-
if (m !=l && strcasecmp(pasLayers[m].name, pasLayers[l].name)== 0 &&
185+
if (m !=l && strcasecmp(pasSLDLayers[m].name, pasSLDLayers[l].name)== 0 &&
194186
nIndex != -1) {
195187
psTmpLayer = (layerObj *) malloc(sizeof(layerObj));
196188
initLayer(psTmpLayer, map);
@@ -205,92 +197,106 @@ int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer, const char *psz
205197
if (psTmpLayer->name)
206198
msFree(psTmpLayer->name);
207199
psTmpLayer->name = msStrdup(tmpId);
208-
msFree(pasLayers[l].name);
209-
pasLayers[l].name = msStrdup(tmpId);
200+
msFree(pasSLDLayers[l].name);
201+
pasSLDLayers[l].name = msStrdup(tmpId);
210202
msInsertLayer(map, psTmpLayer, -1);
211203
MS_REFCNT_DECR(psTmpLayer);
212204
}
213205
}
214206
}
215207
for (i=0; i<map->numlayers; i++) {
208+
layerObj *lp = NULL;
209+
const char *pszWMSLayerName = NULL;
210+
int j;
211+
int bUseSpecificLayer = 0;
212+
216213
if (iLayer >=0 && iLayer< map->numlayers) {
217214
i = iLayer;
218215
bUseSpecificLayer = 1;
219216
}
220217

218+
lp = GET_LAYER(map, i);
219+
221220
/* compare layer name to wms_name as well */
222-
pszTmp = msOWSLookupMetadata(&(GET_LAYER(map, i)->metadata), "MO", "name");
221+
pszWMSLayerName = msOWSLookupMetadata(&(lp->metadata), "MO", "name");
222+
223+
for (j=0; j<nSLDLayers; j++) {
224+
layerObj* sldLayer = &pasSLDLayers[j];
223225

224-
for (j=0; j<nLayers; j++) {
225226
/* -------------------------------------------------------------------- */
226227
/* copy : - class */
227228
/* - layer's labelitem */
228229
/* -------------------------------------------------------------------- */
229-
if ((pasLayers[j].name && pszStyleLayerName == NULL &&
230-
((strcasecmp(GET_LAYER(map, i)->name, pasLayers[j].name) == 0 ||
231-
(pszTmp && strcasecmp(pszTmp, pasLayers[j].name) == 0))||
232-
(GET_LAYER(map, i)->group &&
233-
strcasecmp(GET_LAYER(map, i)->group, pasLayers[j].name) == 0))) ||
234-
(bUseSpecificLayer && pszStyleLayerName && pasLayers[j].name &&
235-
strcasecmp(pasLayers[j].name, pszStyleLayerName) == 0)) {
230+
if ((sldLayer->name && pszStyleLayerName == NULL &&
231+
((strcasecmp(lp->name, sldLayer->name) == 0 ||
232+
(pszWMSLayerName && strcasecmp(pszWMSLayerName, sldLayer->name) == 0))||
233+
(lp->group &&
234+
strcasecmp(lp->group, sldLayer->name) == 0))) ||
235+
(bUseSpecificLayer && pszStyleLayerName && sldLayer->name &&
236+
strcasecmp(sldLayer->name, pszStyleLayerName) == 0)) {
236237
#ifdef notdef
237238
/*this is a test code if we decide to flag some layers as not supporting SLD*/
238-
pszSLDNotSupported = msOWSLookupMetadata(&(GET_LAYER(map, i)->metadata), "M", "SLD_NOT_SUPPORTED");
239+
pszSLDNotSupported = msOWSLookupMetadata(&(lp->metadata), "M", "SLD_NOT_SUPPORTED");
239240
if (pszSLDNotSupported) {
240-
msSetError(MS_WMSERR, "Layer %s does not support SLD", "msSLDApplySLD", pasLayers[j].name);
241+
msSetError(MS_WMSERR, "Layer %s does not support SLD", "msSLDApplySLD", sldLayer->name);
241242
nsStatus = MS_FAILURE;
242243
goto sld_cleanup;
243244
}
244245
#endif
245246

246-
if ( pasLayers[j].numclasses > 0) {
247-
GET_LAYER(map, i)->type = pasLayers[j].type;
247+
if ( sldLayer->numclasses > 0) {
248+
int iClass = 0;
249+
int k;
248250

249-
for(k=0; k<GET_LAYER(map, i)->numclasses; k++) {
250-
if (GET_LAYER(map, i)->class[k] != NULL) {
251-
GET_LAYER(map, i)->class[k]->layer=NULL;
252-
if (freeClass(GET_LAYER(map, i)->class[k]) == MS_SUCCESS ) {
253-
msFree(GET_LAYER(map, i)->class[k]);
254-
GET_LAYER(map, i)->class[k] = NULL;
251+
lp->type = sldLayer->type;
252+
253+
for(k=0; k<lp->numclasses; k++) {
254+
if (lp->class[k] != NULL) {
255+
lp->class[k]->layer=NULL;
256+
if (freeClass(lp->class[k]) == MS_SUCCESS ) {
257+
msFree(lp->class[k]);
258+
lp->class[k] = NULL;
255259
}
256260
}
257261
}
258262

259-
GET_LAYER(map, i)->numclasses = 0;
263+
lp->numclasses = 0;
260264

261265
/*unset the classgroup on the layer if it was set. This allows the layer to render
262266
with all the classes defined in the SLD*/
263-
msFree(GET_LAYER(map, i)->classgroup);
264-
GET_LAYER(map, i)->classgroup = NULL;
267+
msFree(lp->classgroup);
268+
lp->classgroup = NULL;
265269

266-
iClass = 0;
267-
for (k=0; k < pasLayers[j].numclasses; k++) {
268-
if (msGrowLayerClasses(GET_LAYER(map, i)) == NULL)
270+
for (k=0; k < sldLayer->numclasses; k++) {
271+
if (msGrowLayerClasses(lp) == NULL)
269272
return MS_FAILURE;
270273

271-
initClass(GET_LAYER(map, i)->class[iClass]);
272-
msCopyClass(GET_LAYER(map, i)->class[iClass],
273-
pasLayers[j].class[k], NULL);
274-
GET_LAYER(map, i)->class[iClass]->layer = GET_LAYER(map, i);
275-
GET_LAYER(map, i)->numclasses++;
274+
initClass(lp->class[iClass]);
275+
msCopyClass(lp->class[iClass],
276+
sldLayer->class[k], NULL);
277+
lp->class[iClass]->layer = lp;
278+
lp->numclasses++;
276279

277280
/*aliases may have been used as part of the sld text symbolizer for
278281
label element. Try to process it if that is the case #3114*/
279-
if (msLayerOpen(GET_LAYER(map, i)) == MS_SUCCESS &&
280-
msLayerGetItems(GET_LAYER(map, i)) == MS_SUCCESS) {
281-
if (GET_LAYER(map, i)->class[iClass]->text.string) {
282-
for(z=0; z<GET_LAYER(map, i)->numitems; z++) {
283-
if (!GET_LAYER(map, i)->items[z] || strlen(GET_LAYER(map, i)->items[z]) <= 0)
282+
if (msLayerOpen(lp) == MS_SUCCESS &&
283+
msLayerGetItems(lp) == MS_SUCCESS) {
284+
if (lp->class[iClass]->text.string) {
285+
int z;
286+
for(z=0; z<lp->numitems; z++) {
287+
const char* pszFullName;
288+
char szTmp[512];
289+
char* pszTmp1;
290+
if (!lp->items[z] || strlen(lp->items[z]) <= 0)
284291
continue;
285-
snprintf(szTmp, sizeof(szTmp), "%s_alias", GET_LAYER(map, i)->items[z]);
286-
pszFullName = msOWSLookupMetadata(&(GET_LAYER(map, i)->metadata), "G", szTmp);
287-
pszTmp1 = msStrdup( GET_LAYER(map, i)->class[iClass]->text.string);
292+
snprintf(szTmp, sizeof(szTmp), "%s_alias", lp->items[z]);
293+
pszFullName = msOWSLookupMetadata(&(lp->metadata), "G", szTmp);
294+
pszTmp1 = msStrdup( lp->class[iClass]->text.string);
288295
if (pszFullName != NULL && (strstr(pszTmp1, pszFullName) != NULL)) {
289-
char *tmpstr1= NULL;
290-
tmpstr1 = msReplaceSubstring(pszTmp1, pszFullName, GET_LAYER(map, i)->items[z]);
291-
pszTmp2 = (char *)malloc(sizeof(char)*(strlen(tmpstr1)+3));
296+
char *tmpstr1= msReplaceSubstring(pszTmp1, pszFullName, lp->items[z]);
297+
char* pszTmp2 = (char *)malloc(sizeof(char)*(strlen(tmpstr1)+3));
292298
sprintf(pszTmp2,"(%s)",tmpstr1);
293-
msLoadExpressionString(&(GET_LAYER(map, i)->class[iClass]->text), pszTmp2);
299+
msLoadExpressionString(&(lp->class[iClass]->text), pszTmp2);
294300
msFree(pszTmp2);
295301
}
296302
msFree(pszTmp1);
@@ -302,69 +308,66 @@ int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer, const char *psz
302308
}
303309
} else {
304310
/*this is probably an SLD that uses Named styles*/
305-
if (pasLayers[j].classgroup) {
306-
for (k=0; k<GET_LAYER(map, i)->numclasses; k++) {
307-
if (GET_LAYER(map, i)->class[k]->group &&
308-
strcasecmp(GET_LAYER(map, i)->class[k]->group,
309-
pasLayers[j].classgroup) == 0)
311+
if (sldLayer->classgroup) {
312+
int k;
313+
for (k=0; k<lp->numclasses; k++) {
314+
if (lp->class[k]->group &&
315+
strcasecmp(lp->class[k]->group,
316+
sldLayer->classgroup) == 0)
310317
break;
311318
}
312-
if (k < GET_LAYER(map, i)->numclasses) {
313-
msFree( GET_LAYER(map, i)->classgroup);
314-
GET_LAYER(map, i)->classgroup = msStrdup(pasLayers[j].classgroup);
319+
if (k < lp->numclasses) {
320+
msFree( lp->classgroup);
321+
lp->classgroup = msStrdup(sldLayer->classgroup);
315322
} else {
316323
/* TODO we throw an exception ?*/
317324
}
318325
}
319326
}
320-
if (pasLayers[j].labelitem) {
321-
if (GET_LAYER(map, i)->labelitem)
322-
free(GET_LAYER(map, i)->labelitem);
327+
if (sldLayer->labelitem) {
328+
if (lp->labelitem)
329+
free(lp->labelitem);
323330

324-
GET_LAYER(map, i)->labelitem = msStrdup(pasLayers[j].labelitem);
331+
lp->labelitem = msStrdup(sldLayer->labelitem);
325332
}
326333

327-
if (pasLayers[j].classitem) {
328-
if (GET_LAYER(map, i)->classitem)
329-
free(GET_LAYER(map, i)->classitem);
334+
if (sldLayer->classitem) {
335+
if (lp->classitem)
336+
free(lp->classitem);
330337

331-
GET_LAYER(map, i)->classitem = msStrdup(pasLayers[j].classitem);
338+
lp->classitem = msStrdup(sldLayer->classitem);
332339
}
333340

334341
/* opacity for sld raster */
335-
if (GET_LAYER(map, i)->type == MS_LAYER_RASTER &&
336-
pasLayers[j].compositer && pasLayers[j].compositer->opacity != 100)
337-
msSetLayerOpacity(GET_LAYER(map, i), pasLayers[j].compositer->opacity);
342+
if (lp->type == MS_LAYER_RASTER &&
343+
sldLayer->compositer && sldLayer->compositer->opacity != 100)
344+
msSetLayerOpacity(lp, sldLayer->compositer->opacity);
338345

339346
/* mark as auto-generate SLD */
340-
if (GET_LAYER(map, i)->connectiontype == MS_WMS)
341-
msInsertHashTable(&(GET_LAYER(map, i)->metadata),
347+
if (lp->connectiontype == MS_WMS)
348+
msInsertHashTable(&(lp->metadata),
342349
"wms_sld_body", "auto" );
343350

344-
lp = GET_LAYER(map, i);
345-
346351
/* The SLD might have a FeatureTypeConstraint */
347-
if( pasLayers[j].filter.type == MS_EXPRESSION )
352+
if( sldLayer->filter.type == MS_EXPRESSION )
348353
{
349354
if( lp->filter.string && lp->filter.type == MS_EXPRESSION )
350355
{
351-
pszBuffer = msStringConcatenate(NULL, "((");
356+
char* pszBuffer = msStringConcatenate(NULL, "((");
352357
pszBuffer = msStringConcatenate(pszBuffer, lp->filter.string);
353358
pszBuffer = msStringConcatenate(pszBuffer, ") AND (");
354-
pszBuffer = msStringConcatenate(pszBuffer, pasLayers[j].filter.string);
359+
pszBuffer = msStringConcatenate(pszBuffer, sldLayer->filter.string);
355360
pszBuffer = msStringConcatenate(pszBuffer, "))");
356361
msFreeExpression(&lp->filter);
357362
msInitExpression(&lp->filter);
358363
lp->filter.string = pszBuffer;
359364
lp->filter.type = MS_EXPRESSION;
360-
361-
pszBuffer = NULL;
362365
}
363366
else
364367
{
365368
msFreeExpression(&lp->filter);
366369
msInitExpression(&lp->filter);
367-
lp->filter.string = msStrdup(pasLayers[j].filter.string);
370+
lp->filter.string = msStrdup(sldLayer->filter.string);
368371
lp->filter.type = MS_EXPRESSION;
369372
}
370373
}
@@ -379,11 +382,14 @@ int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer, const char *psz
379382
/* check first that all classes have an expression type. That is
380383
the only way we can concatenate them and set the filter
381384
expression */
385+
int k;
382386
for (k=0; k<lp->numclasses; k++) {
383387
if (lp->class[k]->expression.type != MS_EXPRESSION)
384388
break;
385389
}
386390
if (k == lp->numclasses) {
391+
char szTmp[512];
392+
char* pszBuffer = NULL;
387393
for (k=0; k<lp->numclasses; k++) {
388394
if (pszBuffer == NULL)
389395
snprintf(szTmp, sizeof(szTmp), "%s", "(("); /* we a building a string expression, explicitly set type below */
@@ -403,7 +409,6 @@ int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer, const char *psz
403409
lp->filter.type = MS_EXPRESSION;
404410

405411
msFree(pszBuffer);
406-
pszBuffer = NULL;
407412
}
408413
}
409414
}
@@ -421,11 +426,11 @@ int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer, const char *psz
421426
/* -------------------------------------------------------------------- */
422427
if (ppszLayerNames) {
423428
char *pszTmp = NULL;
424-
for (i=0; i<nLayers; i++) {
425-
if (pasLayers[i].name) {
429+
for (i=0; i<nSLDLayers; i++) {
430+
if (pasSLDLayers[i].name) {
426431
if (pszTmp !=NULL)
427432
pszTmp = msStringConcatenate(pszTmp, ",");
428-
pszTmp = msStringConcatenate(pszTmp, pasLayers[i].name);
433+
pszTmp = msStringConcatenate(pszTmp, pasSLDLayers[i].name);
429434

430435
}
431436
}
@@ -439,12 +444,15 @@ int msSLDApplySLD(mapObj *map, const char *psSLDXML, int iLayer, const char *psz
439444
#ifdef notdef
440445
sld_cleanup:
441446
#endif
442-
for (i=0; i<nLayers; i++)
443-
freeLayer(&pasLayers[i]);
444-
msFree(pasLayers);
447+
{
448+
int i;
449+
for (i=0; i<nSLDLayers; i++)
450+
freeLayer(&pasSLDLayers[i]);
451+
msFree(pasSLDLayers);
452+
}
445453

446454
if(map->debug == MS_DEBUGLEVEL_VVV) {
447-
tmpfilename = msTmpFile(map, map->mappath, NULL, "_sld.map");
455+
char* tmpfilename = msTmpFile(map, map->mappath, NULL, "_sld.map");
448456
if (tmpfilename == NULL) {
449457
tmpfilename = msTmpFile(map, NULL, NULL, "_sld.map" );
450458
}

0 commit comments

Comments
 (0)