int Rast3d_get_standard3d_params(int *useTypeDefault, int *type, int *useCompressionDefault, int *doCompression, int *usePrecisionDefault, int *precision, int *useDimensionDefault, int *tileX, int *tileY, int *tileZ) { *useTypeDefault = *useCompressionDefault = 0; *usePrecisionDefault = *useDimensionDefault = 0; Rast3d_init_defaults(); if (strcmp(param->type->answer, "double") == 0) *type = DCELL_TYPE; else if (strcmp(param->type->answer, "float") == 0) *type = FCELL_TYPE; else { *type = Rast3d_get_file_type(); *useTypeDefault = 1; } Rast3d_get_compression_mode(doCompression, precision); if (strcmp(param->precision->answer, "default") != 0) { if (strcmp(param->precision->answer, "max") == 0) *precision = -1; else if ((sscanf(param->precision->answer, "%d", precision) != 1) || (*precision < 0)) { Rast3d_error(_("Rast3d_get_standard3d_params: precision value invalid")); return 0; } } else *usePrecisionDefault = 1; if (strcmp(param->compression->answer, "default") != 0) { if (strcmp(param->compression->answer, "zip") == 0) *doCompression = RASTER3D_COMPRESSION; else *doCompression = RASTER3D_NO_COMPRESSION; } else { *useCompressionDefault = 1; } Rast3d_get_tile_dimension(tileX, tileY, tileZ); if (strcmp(param->dimension->answer, "default") != 0) { if (sscanf(param->dimension->answer, "%dx%dx%d", tileX, tileY, tileZ) != 3) { Rast3d_error(_("Rast3d_get_standard3d_params: tile dimension value invalid")); return 0; } } else *useDimensionDefault = 1; Rast3d_free(param); return 1; }
void *Rast3d_open_cell_old_no_header(const char *name, const char *mapset) { RASTER3D_Map *map; char xname[GNAME_MAX], xmapset[GMAPSET_MAX]; Rast3d_init_defaults(); if (!Rast3d_mask_open_old()) { Rast3d_error(_("Rast3d_open_cell_old_no_header: error in Rast3d_mask_open_old")); return (void *)NULL; } map = Rast3d_malloc(sizeof(RASTER3D_Map)); if (map == NULL) { Rast3d_error(_("Rast3d_open_cell_old_no_header: error in Rast3d_malloc")); return (void *)NULL; } G_unqualified_name(name, mapset, xname, xmapset); map->fileName = G_store(xname); map->mapset = G_store(xmapset); map->data_fd = G_open_old_misc(RASTER3D_DIRECTORY, RASTER3D_CELL_ELEMENT, xname, xmapset); if (map->data_fd < 0) { Rast3d_error(_("Rast3d_open_cell_old_no_header: error in G_open_old")); return (void *)NULL; } Rast3d_range_init(map); Rast3d_mask_off(map); return map; }
void *Rast3d_get_tile_ptr(RASTER3D_Map * map, int tileIndex) { void *ptr; if ((tileIndex >= map->nTiles) || (tileIndex < 0)) { Rast3d_error("Rast3d_get_tile_ptr: tileIndex out of range"); return NULL; } if (map->useCache) { ptr = Rast3d_cache_elt_ptr(map->cache, tileIndex); if (ptr == NULL) { Rast3d_error("Rast3d_get_tile_ptr: error in Rast3d_cache_elt_ptr"); return NULL; } return ptr; } if (map->currentIndex == tileIndex) return map->data; map->currentIndex = tileIndex; if (!Rast3d_read_tile(map, map->currentIndex, map->data, map->typeIntern)) { Rast3d_error("Rast3d_get_tile_ptr: error in Rast3d_read_tile"); return NULL; } return map->data; }
static int cache_remove_elt(RASTER3D_cache * c, int name, int doFlush) { int index; index = Rast3d_cache_hash_name2index(c->hash, name); if (index == -1) { Rast3d_error("Rast3d_cache_deactivate_elt : name not in cache"); return 0; } if (IS_NOT_ACTIVE_ELT(index)) return 1; if (IS_IN_QUEUE_ELT(index)) { cache_queue_dequeue(c, index); LOCK_ELT(index); } if (doFlush) if (!c->eltRemoveFun(name, c->elts + c->eltSize * index, c->eltRemoveFunData)) { Rast3d_error("cache_remove_elt: error in c->eltRemoveFun"); return 0; } cache_queue_preppend(c, index); DEACTIVATE_ELT(index); Rast3d_cache_hash_remove_name(c->hash, name); return 1; }
static int Rast3d_tile2xdrTile(RASTER3D_Map * map, const void *tile, int rows, int cols, int depths, int xRedundant, int yRedundant, int zRedundant, int nofNum, int type) { int y, z; if (!Rast3d_init_copy_to_xdr(map, type)) { Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_init_copy_to_xdr"); return 0; } if (nofNum == map->tileSize) { if (!Rast3d_copy_to_xdr(tile, map->tileSize)) { Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_copy_to_xdr"); return 0; } return 1; } if (xRedundant) { for (z = 0; z < depths; z++) { for (y = 0; y < rows; y++) { if (!Rast3d_copy_to_xdr(tile, cols)) { Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_copy_to_xdr"); return 0; } tile = G_incr_void_ptr(tile, map->tileX * Rast3d_length(type)); } if (yRedundant) tile = G_incr_void_ptr(tile, map->tileX * yRedundant * Rast3d_length(type)); } return 1; } if (yRedundant) { for (z = 0; z < depths; z++) { if (!Rast3d_copy_to_xdr(tile, map->tileX * rows)) { Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_copy_to_xdr"); return 0; } tile = G_incr_void_ptr(tile, map->tileXY * Rast3d_length(type)); } return 1; } if (!Rast3d_copy_to_xdr(tile, map->tileXY * depths)) { Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_copy_to_xdr"); return 0; } return 1; }
int Rast3d_flush_index(RASTER3D_Map * map) { int sizeCompressed, indexLength, tileIndex; unsigned char *tmp; long ldummy; if (!map->hasIndex) return 1; map->indexOffset = lseek(map->data_fd, (long)0, SEEK_END); if (map->indexOffset == -1) { Rast3d_error("Rast3d_flush_index: can't rewind file"); return 0; } map->indexNbytesUsed = Rast3d_long_encode(&(map->indexOffset), (unsigned char *)&ldummy, 1); tmp = Rast3d_malloc(sizeof(long) * map->nTiles); if (tmp == NULL) { Rast3d_error("Rast3d_flush_index: error in Rast3d_malloc"); return 0; } for (tileIndex = 0; tileIndex < map->nTiles; tileIndex++) if (map->index[tileIndex] == -1) map->index[tileIndex] = 0; (void)Rast3d_long_encode(map->index, tmp, map->nTiles); sizeCompressed = Rast3d_rle_count_only(tmp, sizeof(long) * map->nTiles, 1); if (sizeCompressed >= map->nTiles * sizeof(long)) { indexLength = map->nTiles * sizeof(long); if (write(map->data_fd, tmp, indexLength) != indexLength) { Rast3d_error("Rast3d_flush_index: can't write file"); return 0; } } else { indexLength = sizeCompressed; Rast3d_rle_encode(tmp, (char *)map->index, sizeof(long) * map->nTiles, 1); if (write(map->data_fd, map->index, sizeCompressed) != sizeCompressed) { Rast3d_error("Rast3d_flush_index: can't write file"); return 0; } } Rast3d_free(tmp); if (!Rast3d_readIndex(map)) { Rast3d_error("Rast3d_flush_index: error in Rast3d_readIndex"); return 0; } return 1; }
int Rast3d_write_tile(RASTER3D_Map * map, int tileIndex, const void *tile, int type) { int rows, cols, depths, xRedundant, yRedundant, zRedundant, nofNum; /* valid tileIndex ? */ if ((tileIndex >= map->nTiles) || (tileIndex < 0)) Rast3d_fatal_error("Rast3d_write_tile: tileIndex out of range"); /* already written ? */ if (map->index[tileIndex] != -1) return 2; /* save the file position */ map->index[tileIndex] = lseek(map->data_fd, (long)0, SEEK_END); if (map->index[tileIndex] == -1) { Rast3d_error("Rast3d_write_tile: can't position file"); return 0; } nofNum = Rast3d_compute_clipped_tile_dimensions(map, tileIndex, &rows, &cols, &depths, &xRedundant, &yRedundant, &zRedundant); Rast3d_range_update_from_tile(map, tile, rows, cols, depths, xRedundant, yRedundant, zRedundant, nofNum, type); if (!Rast3d_tile2xdrTile(map, tile, rows, cols, depths, xRedundant, yRedundant, zRedundant, nofNum, type)) { Rast3d_error("Rast3d_writeTileCompressed: error in Rast3d_tile2xdrTile"); return 0; } if (map->compression == RASTER3D_NO_COMPRESSION) { if (!Rast3d_writeTileUncompressed(map, nofNum)) { Rast3d_error("Rast3d_write_tile: error in Rast3d_writeTileUncompressed"); return 0; } } else if (!Rast3d_writeTileCompressed(map, nofNum)) { Rast3d_error("Rast3d_write_tile: error in Rast3d_writeTileCompressed"); return 0; } /* compute the length */ map->tileLength[tileIndex] = lseek(map->data_fd, (long)0, SEEK_END) - map->index[tileIndex]; return 1; }
void *Rast3d_cache_new(int nofElts, int sizeOfElts, int nofNames, int (*eltRemoveFun) (), void *eltRemoveFunData, int (*eltLoadFun) (), void *eltLoadFunData) { RASTER3D_cache *tmp; int i; tmp = Rast3d_malloc(sizeof(RASTER3D_cache)); if (tmp == NULL) { Rast3d_error("Rast3d_cache_new: error in Rast3d_malloc"); return (void *)NULL; } tmp->hash = NULL; tmp->nofElts = nofElts; tmp->eltSize = sizeOfElts; tmp->elts = Rast3d_malloc(tmp->eltSize * tmp->nofElts); tmp->names = Rast3d_malloc(sizeof(int) * tmp->nofElts); tmp->locks = Rast3d_malloc(tmp->nofElts); tmp->next = Rast3d_malloc(sizeof(int) * tmp->nofElts); tmp->prev = Rast3d_malloc(sizeof(int) * tmp->nofElts); if ((tmp->elts == NULL) || (tmp->names == NULL) || (tmp->locks == NULL) || (tmp->next == NULL) || (tmp->prev == NULL)) { Rast3d_cache_dispose(tmp); Rast3d_error("Rast3d_cache_new: error in Rast3d_malloc"); return (void *)NULL; } /* Init the cache lock */ for(i = 0; i < tmp->nofElts; i++) tmp->locks[i] = 0; tmp->eltRemoveFun = eltRemoveFun; tmp->eltRemoveFunData = eltRemoveFunData; tmp->eltLoadFun = eltLoadFun; tmp->eltLoadFunData = eltLoadFunData; tmp->hash = Rast3d_cache_hash_new(nofNames); if (tmp->hash == NULL) { Rast3d_cache_dispose(tmp); Rast3d_error("Rast3d_cache_new: error in Rast3d_cache_hash_new"); return (void *)NULL; } Rast3d_cache_reset(tmp); return tmp; }
int Rast3d_init_copy_from_xdr(RASTER3D_Map * map, int dType) { xdrTmp = xdr; useXdr = map->useXdr; dstType = dType; if (useXdr == RASTER3D_USE_XDR) { if (!xdr_setpos(&(xdrDecodeStream), 0)) { Rast3d_error("Rast3d_init_copy_from_xdr: positioning xdr failed"); return 0; } xdrs = &(xdrDecodeStream); } type = map->type; isFloat = (type == FCELL_TYPE); externLength = Rast3d_extern_length(type); eltLength = Rast3d_length(dstType); if (isFloat) xdrFun = xdr_float; else xdrFun = xdr_double; tmp = &tmpValue; return 1; }
void *Rast3d_cache_elt_ptr(RASTER3D_cache * c, int name) { int index, oldName, doUnlock; index = Rast3d_cache_hash_name2index(c->hash, name); if (index != -1) { if (c->autoLock) if (IS_UNLOCKED_ELT(index) && (!ONE_UNLOCKED_ELT_ONLY) && (!ARE_MIN_UNLOCKED)) Rast3d_cache_lock_intern(c, index); return c->elts + c->eltSize * index; } index = c->first; if (IS_ACTIVE_ELT(index)) { oldName = c->names[index]; Rast3d_cache_hash_remove_name(c->hash, oldName); if (!c->eltRemoveFun(oldName, c->elts + c->eltSize * index, c->eltRemoveFunData)) { Rast3d_error("Rast3d_cache_elt_ptr: error in c->eltRemoveFun"); return NULL; } } Rast3d_cache_hash_load_name(c->hash, name, index); doUnlock = ((!c->autoLock) || ONE_UNLOCKED_ELT_ONLY || ARE_MIN_UNLOCKED); UNLOCK_ELT(index); c->names[index] = name; Rast3d_cache_lock_intern(c, index); if (doUnlock) if (!Rast3d_cache_unlock(c, name)) { Rast3d_error("Rast3d_cache_elt_ptr: error in Rast3d_cache_unlock"); return NULL; } if (!c->eltLoadFun(name, c->elts + c->eltSize * index, c->eltLoadFunData)) { Rast3d_error("Rast3d_cache_elt_ptr: error in c->eltLoadFun"); return NULL; } return c->elts + c->eltSize * index; }
int Rast3d_init_fp_xdr(RASTER3D_Map * map, int misuseBytes) /* nof addtl bytes allocated for the xdr array so that */ /* the array can also be (mis)used for other purposes */ { int doAlloc; doAlloc = 0; if (xdr == NULL) { xdrLength = map->tileSize * RASTER3D_MAX(map->numLengthExtern, map->numLengthIntern) + misuseBytes; xdr = Rast3d_malloc(xdrLength); if (xdr == NULL) { Rast3d_error("Rast3d_init_fp_xdr: error in Rast3d_malloc"); return 0; } doAlloc = 1; } else if (map->tileSize * RASTER3D_MAX(map->numLengthExtern, map->numLengthIntern) + misuseBytes > xdrLength) { xdrLength = map->tileSize * RASTER3D_MAX(map->numLengthExtern, map->numLengthIntern) + misuseBytes; xdr = Rast3d_realloc(xdr, xdrLength); if (xdr == NULL) { Rast3d_error("Rast3d_init_fp_xdr: error in Rast3d_realloc"); return 0; } doAlloc = 1; } if (doAlloc) { xdrmem_create(&(xdrEncodeStream), xdr, (u_int) xdrLength, XDR_ENCODE); xdrmem_create(&(xdrDecodeStream), xdr, (u_int) xdrLength, XDR_DECODE); } return 1; }
int Rast3d_cache_flush(RASTER3D_cache * c, int name) { if (!cache_remove_elt(c, name, 1)) { Rast3d_error("Rast3d_cache_flush: error in cache_remove_elt"); return 0; } return 1; }
int Rast3d_cache_load(RASTER3D_cache * c, int name) { if (Rast3d_cache_elt_ptr(c, name) == NULL) { Rast3d_error("Rast3d_cache_load: error in Rast3d_cache_elt_ptr"); return 0; } return 1; }
int Rast3d_tile_load(RASTER3D_Map * map, int tileIndex) { if (Rast3d_get_tile_ptr(map, tileIndex) == NULL) { Rast3d_error("Rast3d_tile_load: error in Rast3d_get_tile_ptr"); return 0; } return 1; }
int Rast3d_write_tile_double(RASTER3D_Map * map, int tileIndex, const void *tile) { int status; if ((status = Rast3d_write_tile(map, tileIndex, tile, DCELL_TYPE))) return status; Rast3d_error("Rast3d_write_tile_double: error in Rast3d_write_tile"); return 0; }
int Rast3d_copy_from_xdr(int nofNum, void *dst) { int i; if (useXdr == RASTER3D_NO_XDR) { Rast3d_copy_values(xdrTmp, 0, type, dst, 0, dstType, nofNum); xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * Rast3d_extern_length(type)); return 1; } for (i = 0; i < nofNum; i++, dst = G_incr_void_ptr(dst, eltLength)) { if (Rast3d_is_xdr_null_num(xdrTmp, isFloat)) { Rast3d_set_null_value(dst, 1, dstType); if (!xdr_setpos(xdrs, xdr_getpos(xdrs) + externLength)) { Rast3d_error("Rast3d_copy_from_xdr: positioning xdr failed"); return 0; } } else { if (type == dstType) { if (xdrFun(xdrs, dst) < 0) { Rast3d_error("Rast3d_copy_from_xdr: reading xdr failed"); return 0; } } else { if (xdrFun(xdrs, tmp) < 0) { Rast3d_error("Rast3d_copy_from_xdr: reading xdr failed"); return 0; } if (type == FCELL_TYPE) *((double *)dst) = (double)*((float *)tmp); else *((float *)dst) = (float)*((double *)tmp); } } xdrTmp = G_incr_void_ptr(xdrTmp, externLength); } return 1; }
int Rast3d_copy_to_xdr(const void *src, int nofNum) { int i; if (useXdr == RASTER3D_NO_XDR) { Rast3d_copy_values(src, 0, srcType, xdrTmp, 0, type, nofNum); xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * Rast3d_extern_length(type)); return 1; } for (i = 0; i < nofNum; i++, src = G_incr_void_ptr(src, eltLength)) { if (Rast3d_is_null_value_num(src, srcType)) { Rast3d_set_xdr_null_num(xdrTmp, isFloat); if (!xdr_setpos(xdrs, xdr_getpos(xdrs) + externLength)) { Rast3d_error("Rast3d_copy_to_xdr: positioning xdr failed"); return 0; } } else { if (type == srcType) { if (xdrFun(xdrs, src) < 0) { Rast3d_error("Rast3d_copy_to_xdr: writing xdr failed"); return 0; } } else { if (type == FCELL_TYPE) *((float *)tmp) = (float)*((double *)src); else *((double *)tmp) = (double)*((float *)src); if (xdrFun(xdrs, tmp) < 0) { Rast3d_error("Rast3d_copy_to_xdr: writing xdr failed"); return 0; } } } xdrTmp = G_incr_void_ptr(xdrTmp, externLength); } return 1; }
static int Rast3d_writeTileUncompressed(RASTER3D_Map * map, int nofNum) { if (write(map->data_fd, xdr, map->numLengthExtern * nofNum) != map->numLengthExtern * nofNum) { Rast3d_error("Rast3d_writeTileUncompressed: can't write file."); return 0; } return 1; }
int Rast3d_read_window(RASTER3D_Region * window, const char *windowName) { struct Cell_head win; struct Key_Value *windowKeys; char path[GPATH_MAX]; if (windowName == NULL) { G_get_window(&win); window->proj = win.proj; window->zone = win.zone; window->north = win.north; window->south = win.south; window->east = win.east; window->west = win.west; window->top = win.top; window->bottom = win.bottom; window->rows = win.rows3; window->cols = win.cols3; window->depths = win.depths; window->ns_res = win.ns_res3; window->ew_res = win.ew_res3; window->tb_res = win.tb_res; } else { Rast3d_getFullWindowPath(path, windowName); if (access(path, R_OK) != 0) { G_warning("Rast3d_read_window: unable to find [%s].", path); return 0; } windowKeys = G_read_key_value_file(path); if (!Rast3d_readWriteWindow(windowKeys, 1, &(window->proj), &(window->zone), &(window->north), &(window->south), &(window->east), &(window->west), &(window->top), &(window->bottom), &(window->rows), &(window->cols), &(window->depths), &(window->ew_res), &(window->ns_res), &(window->tb_res))) { Rast3d_error ("Rast3d_read_window: error extracting window key(s) of file %s", path); return 0; } G_free_key_value(windowKeys); } return 1; }
void *Rast3d_alloc_tiles(RASTER3D_Map * map, int nofTiles) { void *tiles; tiles = Rast3d_alloc_tiles_type(map, nofTiles, map->typeIntern); if (tiles == NULL) { Rast3d_error("Rast3d_alloc_tiles: error in Rast3d_alloc_tiles_type"); return NULL; } return tiles; }
void *Rast3d_alloc_tiles_type(RASTER3D_Map * map, int nofTiles, int type) { void *tiles; tiles = Rast3d_malloc(map->tileSize * Rast3d_length(type) * nofTiles); if (tiles == NULL) { Rast3d_error("Rast3d_alloc_tiles_type: error in Rast3d_malloc"); return NULL; } return tiles; }
int Rast3d__remove_tile(RASTER3D_Map * map, int tileIndex) { if (!map->useCache) return 1; if (!Rast3d_cache_remove_elt(map->cache, tileIndex)) { Rast3d_error("Rast3d_removeTile: error in Rast3d_cache_remove_elt"); return 0; } return 1; }
static int Rast3d_writeTileCompressed(RASTER3D_Map * map, int nofNum) { if (!Rast3d_fpcompress_write_xdr_nums(map->data_fd, xdr, nofNum, map->precision, tmpCompress, map->type == FCELL_TYPE, map->useRle, map->useLzw)) { Rast3d_error ("Rast3d_writeTileCompressed: error in Rast3d_fpcompress_write_xdr_nums"); return 0; } return 1; }
int Rast3d_write_ints(int fd, int useXdr, const int *i, int nofNum) { char xdrIntBuf[RASTER3D_XDR_INT_LENGTH * 1024]; unsigned int n; if (nofNum <= 0) Rast3d_fatal_error("Rast3d_write_ints: nofNum out of range"); if (useXdr == RASTER3D_NO_XDR) { if (write(fd, i, sizeof(int) * nofNum) != sizeof(int) * nofNum) { Rast3d_error("Rast3d_write_ints: writing to file failed"); return 0; } else { return 1; } } do { int j; n = nofNum % 1024; if (n == 0) n = 1024; for (j = 0; j < n; j++) G_xdr_put_int(&xdrIntBuf[RASTER3D_XDR_INT_LENGTH * j], i); if (write(fd, xdrIntBuf, RASTER3D_XDR_INT_LENGTH * n) != RASTER3D_XDR_INT_LENGTH * n) { Rast3d_error("Rast3d_write_ints: writing xdr to file failed"); return 0; } nofNum -= n; i += n; } while (nofNum); return 1; }
int Rast3d_flush_tile(RASTER3D_Map * map, int tileIndex) { const void *tile; tile = Rast3d_get_tile_ptr(map, tileIndex); if (tile == NULL) { Rast3d_error("Rast3d_flush_tile: error in Rast3d_get_tile_ptr"); return 0; } if (!Rast3d_write_tile(map, tileIndex, tile, map->typeIntern)) { Rast3d_error("Rast3d_flush_tile: error in Rast3d_write_tile"); return 0; } if (!Rast3d__remove_tile(map, tileIndex)) { Rast3d_error("Rast3d_flush_tile: error in Rast3d__remove_tile"); return 0; } return 1; }
int Rast3d_read_ints(int fd, int useXdr, int *i, int nofNum) { char xdrIntBuf[RASTER3D_XDR_INT_LENGTH * 1024]; unsigned int n; if (nofNum <= 0) Rast3d_fatal_error("Rast3d_read_ints: nofNum out of range"); if (useXdr == RASTER3D_NO_XDR) { if (read(fd, i, sizeof(int) * nofNum) != sizeof(int) * nofNum) { Rast3d_error("Rast3d_read_ints: reading from file failed"); return 0; } else { return 1; } } do { int j; n = nofNum % 1024; if (n == 0) n = 1024; if (read(fd, xdrIntBuf, RASTER3D_XDR_INT_LENGTH * n) != RASTER3D_XDR_INT_LENGTH * n) { Rast3d_error("Rast3d_read_ints: reading xdr from file failed"); return 0; } for (j = 0; j < n; j++) G_xdr_get_int(i, &xdrIntBuf[RASTER3D_XDR_INT_LENGTH * j]); nofNum -= n; i += n; } while (nofNum); return 1; }
int Rast3d_cache_flush_all(RASTER3D_cache * c) { int index; for (index = 0; index < c->nofElts; index++) if (IS_ACTIVE_ELT(index)) if (!Rast3d_cache_flush(c, c->names[index])) { Rast3d_error("Rast3d_cache_flush_all: error in Rast3d_cache_flush"); return 0; } return 1; }
int Rast3d_cache_unlock_all(RASTER3D_cache * c) { int index; for (index = 0; index < c->nofElts; index++) if (IS_LOCKED_ELT(index)) if (!Rast3d_cache_unlock(c, c->names[index])) { Rast3d_error("Rast3d_cache_unlock_all: error in Rast3d_cache_unlock"); return 0; } return 1; }
int Rast3d_cache_put_elt(RASTER3D_cache * c, int name, const void *src) { void *elt; elt = Rast3d_cache_elt_ptr(c, name); if (elt == NULL) { Rast3d_error("Rast3d_cache_put_elt: error in Rast3d_cache_elt_ptr"); return 0; } memcpy(elt, src, c->eltSize); return 1; }
int Rast3d_cache_get_elt(RASTER3D_cache * c, int name, void *dst) { const void *elt; elt = Rast3d_cache_elt_ptr(c, name); if (elt == NULL) { Rast3d_error("Rast3d_cache_get_elt: error in Rast3d_cache_elt_ptr"); return 0; } memcpy(dst, elt, c->eltSize); return 1; }