Ignore:
Timestamp:
Apr 3, 2011 12:19:30 PM (5 years ago)
Author:
strk
Message:

Ticket #855 by Loic Dachary: pgsql2shp fields conversion from predefined list

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/loader/pgsql2shp-core.c

    r6524 r6996  
    2929#include <math.h>
    3030#include <sys/types.h>
     31#include <sys/stat.h>
    3132/* Solaris9 does not provide stdint.h */
    3233/* #include <stdint.h> */
     
    11411142        config->keep_fieldname_case = 0;
    11421143        config->fetchsize = 100;
    1143 }
    1144 
     1144        config->geo_map_filename = 0;
     1145}
     1146
     1147/**
     1148 * Read the content of filename into a symbol map stored
     1149 * at state->geo_map.
     1150 *
     1151 * The content of the file is lines of two symbols separated by
     1152 * a single white space and no trailing or leading space:
     1153 *
     1154 *    VERYLONGSYMBOL SHORTONE\n
     1155 *    ANOTHERVERYLONGSYMBOL SHORTER\n
     1156 *
     1157 *    etc.
     1158 *
     1159 * The file is read in core (one large malloc'd area), each
     1160 * space and newline is replaced by a null character. A pointer
     1161 * to the start of each line is stored in the state->geo_map
     1162 * table.
     1163 *
     1164 * It is the reponsibility of the caller to reclaim the allocated space
     1165 * as follows:
     1166 *
     1167 * free(*state->geo_map) to free the file content
     1168 * free(state->geo_map) to free the pointer list
     1169 *
     1170 * @param filename : path to a readable map file in the format
     1171 *                   described above.
     1172 * @param state : container of state->geo_map where the malloc'd
     1173 *                symbol map will be stored.
     1174 *
     1175 * @return state->geo_map : NULL on error, symbol map pointer on
     1176 *                          success.
     1177 */
     1178void
     1179ShpDumperGeoMapRead(char* filename, SHPDUMPERSTATE *state)
     1180{
     1181        struct stat stat_buf;
     1182        static char* content = 0;
     1183        {
     1184                FILE* fp = 0;
     1185                if(stat(filename, &stat_buf) < 0)
     1186                {
     1187                        perror(filename);
     1188                        return;
     1189                }
     1190                content = malloc(stat_buf.st_size);
     1191                fp = fopen(filename, "r");
     1192                if(stat_buf.st_size != fread(content, 1, stat_buf.st_size, fp))
     1193                {
     1194                        free(content);
     1195                        fprintf(stderr, "fread did not return the expected amount of chars");
     1196                        fclose(fp);
     1197                        return;
     1198                }
     1199                fclose(fp);
     1200        }
     1201        {
     1202                int i;
     1203                state->geo_map_size = 0;
     1204
     1205                for(i = 0; i < stat_buf.st_size; i++)
     1206                {
     1207                        if(content[i] == '\n')
     1208                        {
     1209                                state->geo_map_size++;
     1210                        }
     1211                }
     1212                state->geo_map = (char**)malloc(sizeof(char*)*state->geo_map_size);
     1213                {
     1214                        char** map = state->geo_map;
     1215                        *map = content;
     1216                        map++;
     1217                        for(i = 0; i < stat_buf.st_size; i++)
     1218                        {
     1219                                if(content[i] == '\n' && i + 1 < stat_buf.st_size)
     1220                                {
     1221                                        *map = content + i + 1;
     1222                                        map++;
     1223                                }
     1224                                if(content[i] == '\n' || content[i] == ' ')
     1225                                        content[i] = '\0';
     1226                        }
     1227                }
     1228        }
     1229}
    11451230
    11461231/* Create a new shapefile state object */
     
    11621247        state->geo_col_name = NULL;
    11631248
     1249        if(config->geo_map_filename)
     1250        {
     1251                ShpDumperGeoMapRead(config->geo_map_filename, state);
     1252        }
     1253        else
     1254        {
     1255                state->geo_map = NULL;
     1256                state->geo_map_size = 0;
     1257        }
    11641258        return state;
    11651259}
     
    13031397}
    13041398
     1399/**
     1400 * Map a symbol into its 10 chars equivalent according to a map.
     1401 * The map is found in state->geo_map and loaded with the -m option.
     1402 *
     1403 * @param ptr : null terminated string containing the symbol to
     1404 *              be mapped
     1405 * @param state : non null state->geo_map container
     1406 *
     1407 * @return a malloc'd 10 chars symbol that is either the corresponding
     1408 *         symbol found in the state->geo_map or the symbol truncated
     1409 *         to its first 10 chars. The string is null terminated.
     1410 */
     1411char*
     1412ShpDumperFieldnameLimit(char* ptr, SHPDUMPERSTATE *state)
     1413{
     1414        /* Limit dbf field name to 10-digits */
     1415        char* dbffieldname = malloc(11);
     1416        if(state->geo_map)
     1417        {
     1418                int i;
     1419                for(i=0; i<state->geo_map_size; i++)
     1420                {
     1421                        if(!strcasecmp(state->geo_map[i], ptr))
     1422                        {
     1423                                /* the replacement follows the terminating null */
     1424                                ptr = state->geo_map[i] + strlen(state->geo_map[i]) + 1;
     1425                                break;
     1426                        }
     1427                }
     1428        }
     1429        strncpy(dbffieldname, ptr, 10);
     1430        dbffieldname[10] = '\0';
     1431        return dbffieldname;
     1432}
    13051433
    13061434/* Open the specified table in preparation for extracting rows */
     
    14771605
    14781606                /* Limit dbf field name to 10-digits */
    1479                 dbffieldname = malloc(11);
    1480                 strncpy(dbffieldname, ptr, 10);
    1481                 dbffieldname[10] = '\0';
     1607                dbffieldname = ShpDumperFieldnameLimit(ptr, state);
    14821608
    14831609                /*
Note: See TracChangeset for help on using the changeset viewer.