close_nat.c

Go to the documentation of this file.

/*!
   \file lib/vector/Vlib/close_nat.c
 
   \brief Vector library - Close map (native format)
 
   Higher level functions for reading/writing/manipulating vectors.
 
   SPDX-FileCopyrightText: 2001-2015 GRASS Development Team
   SPDX-License-Identifier: GPL-2.0-or-later
 
   \author Original author CERL, probably Dave Gerdes or Mike Higgins.
   \author Update to GRASS 5.7 Radim Blazek and David D. Gray.
 */
 
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
 
#include <grass/vector.h>
#include <grass/glocale.h>
 
#include "local_proto.h"
 
/*!
   \brief Close vector map
 
   \param Map vector map to be closed
 
   \return 0 on success
   \return non-zero on error
 */
int V1_close_nat(struct Map_info *Map)
{
    struct Coor_info CInfo;
 
    G_debug(1, "V1_close_nat(): name = %s mapset= %s", Map->name, Map->mapset);
    if (!VECT_OPEN(Map))
        return 1;
 
    if (Map->mode == GV_MODE_WRITE || Map->mode == GV_MODE_RW) {
        Vect_coor_info(Map, &CInfo);
        Map->head.size = CInfo.size;
        dig__write_head(Map);
 
        Vect__write_head(Map);
        Vect_write_dblinks(Map);
    }
 
    /* close coor file */
    fclose(Map->dig_fp.file);
    dig_file_free(&(Map->dig_fp));
 
    /* delete temporary map ? */
    if (Map->temporary) {
        int delete;
        char *env = getenv("GRASS_VECTOR_TEMPORARY");
 
        delete = TRUE;
        if (Map->temporary == TEMPORARY_MAP_ENV && env) {
            if (G_strcasecmp(env, "move") == 0) {
                /* copy temporary vector map to the current mapset */
                char path_tmp[GPATH_MAX], path_map[GPATH_MAX];
 
                G_debug(1,
                        "V1_close_nat(): temporary map <%s> TO BE MOVED TO"
                        " CURRENT MAPSET",
                        Map->name);
                Vect__get_element_path(path_tmp, Map, NULL);
 
                G_file_name(path_map, GV_DIRECTORY, NULL, Map->mapset);
                if (access(path_map, 0) != 0 && G_mkdir(path_map) != 0)
                    G_fatal_error(_("Unable to create '%s': %s"), path_map,
                                  strerror(errno));
 
                G_file_name(path_map, GV_DIRECTORY, Map->name, Map->mapset);
 
                G_debug(1, "V1_close_nat(): %s -> %s", path_tmp, path_map);
                if (0 != G_recursive_copy(path_tmp, path_map))
                    G_fatal_error(_("Unable to copy '%s': %s"), path_tmp,
                                  strerror(errno));
 
#ifdef TEMPORARY_MAP_DB
                int i, ndblinks;
                int tmp;
 
                struct field_info *fi;
                dbConnection connection;
                struct dblinks *dblinks;
 
                G_debug(1, "V1_close_nat(): copying attributes");
                /* copy also attributes */
                dblinks = Vect_new_dblinks_struct();
                db_get_connection(&connection);
                ndblinks = Vect_get_num_dblinks(Map);
                for (i = 0; i < ndblinks; i++) {
                    fi = Vect_get_dblink(Map, i);
                    if (DB_OK != db_copy_table(fi->driver, fi->database,
                                               fi->table, connection.driverName,
                                               connection.databaseName,
                                               fi->table)) {
                        G_warning(_("Unable to copy table <%s>"), fi->table);
                        continue;
                    }
 
                    Vect_add_dblink(dblinks, fi->number, fi->name, fi->table,
                                    fi->key, connection.databaseName,
                                    connection.driverName);
                    G_free(fi);
                }
                G_free(Map->dblnk);
                Map->dblnk = dblinks;
                tmp = Map->temporary;
                Map->temporary = TEMPORARY_MAP_DISABLED;
                Vect_write_dblinks(Map);
                Map->temporary = tmp;
#endif
            }
            else if (G_strcasecmp(env, "delete") == 0) {
                /* delete temporary vector map */
                G_debug(1, "V1_close_nat(): temporary map <%s> TO BE DELETED",
                        Map->name);
            }
            else {
                /* do not delete temporary vector map */
                G_debug(1, "V1_close_nat(): temporary map <%s> IS NOT DELETED",
                        Map->name);
                delete = FALSE;
            }
        }
        else if (Map->temporary == TEMPORARY_MAP) {
            G_debug(1, "V1_close_nat(): temporary map <%s> TO BE DELETED",
                    Map->name);
            delete = TRUE;
        }
 
        if (delete) {
            char path_tmp[GPATH_MAX];
 
            /* delete vector directory */
            Vect__get_element_path(path_tmp, Map, NULL);
            G_recursive_remove(path_tmp);
 
#ifndef TEMPORARY_MAP_DB
            if (G_strcasecmp(env, "move") != 0) {
                int i, ndblinks;
 
                dbDriver *driver;
                dbString table_name;
 
                struct field_info *fi;
 
                db_init_string(&table_name);
 
                /* drop also attribute table */
                ndblinks = Vect_get_num_dblinks(Map);
                for (i = 0; i < ndblinks; i++) {
                    fi = Vect_get_dblink(Map, i);
 
                    driver =
                        db_start_driver_open_database(fi->driver, fi->database);
                    if (driver == NULL) {
                        G_warning(
                            _("Unable to open database <%s> by driver <%s>"),
                            fi->database, fi->driver);
                        continue;
                    }
 
                    db_set_string(&table_name, fi->table);
                    if (DB_OK != db_drop_table(driver, &table_name)) {
                        G_warning(_("Unable to drop table <%s>"), fi->table);
                        continue;
                    }
                }
            }
#endif
        }
    }
 
    return 0;
}