X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fcase-map.c;h=ed32db0d3fc940cf9d14cd74de02889b9a6721a0;hb=refs%2Fheads%2Fctables7;hp=c54e6753fe74bab580984479e4573dabe9988c04;hpb=fe8dc2171009e90d2335f159d05f7e6660e24780;p=pspp diff --git a/src/data/case-map.c b/src/data/case-map.c index c54e6753fe..ed32db0d3f 100644 --- a/src/data/case-map.c +++ b/src/data/case-map.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2011 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2011, 2013 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -27,6 +27,8 @@ #include "data/variable.h" #include "data/case.h" #include "libpspp/assertion.h" +#include "libpspp/hash-functions.h" +#include "libpspp/hmap.h" #include "gl/xalloc.h" @@ -118,7 +120,7 @@ case_map_get_proto (const struct case_map *map) } /* Creates and returns a new casereader whose cases are produced - by reading from SUBREADER and executing the actions of MAP. + by reading from SUBREADER and executing the actions of MAP. The casereader will have as many `union value's as MAP. When the new casereader is destroyed, MAP will be destroyed too. @@ -127,7 +129,7 @@ case_map_get_proto (const struct case_map *map) when the returned casereader is destroyed. */ struct casereader * case_map_create_input_translator (struct case_map *map, - struct casereader *subreader) + struct casereader *subreader) { return casereader_create_translator (subreader, case_map_get_proto (map), @@ -147,7 +149,7 @@ case_map_create_input_translator (struct case_map *map, when the returned casewriter is destroyed. */ struct casewriter * case_map_create_output_translator (struct case_map *map, - struct casewriter *subwriter) + struct casewriter *subwriter) { return casewriter_create_translator (subwriter, case_map_get_proto (map), @@ -187,7 +189,7 @@ struct case_map * case_map_to_compact_dict (const struct dictionary *d, unsigned int exclude_classes) { - size_t n_vars = dict_get_var_cnt (d); + size_t n_vars = dict_get_n_vars (d); struct caseproto *proto; struct case_map *map; size_t n_values; @@ -209,57 +211,115 @@ case_map_to_compact_dict (const struct dictionary *d, return map; } + +struct stage_var + { + struct hmap_node hmap_node; /* In struct case_map_stage's 'stage_vars'. */ + const struct variable *var; + int case_index; + }; -/* Prepares dictionary D for producing a case map. Afterward, - the caller may delete, reorder, or rename variables within D - at will before using case_map_from_dict() to produce the case +struct case_map_stage + { + const struct dictionary *dict; + struct hmap stage_vars; + }; + +/* Prepares and returns a "struct case_map_stage" for producing a case map for + DICT. Afterward, the caller may delete, reorder, or rename variables within + DICT at will before using case_map_stage_get_case_map() to produce the case map. - Uses D's aux members, which must otherwise not be in use. */ -void -case_map_prepare_dict (const struct dictionary *d) + The caller must *not* add new variables to DICT. */ +struct case_map_stage * +case_map_stage_create (const struct dictionary *dict) { - size_t var_cnt = dict_get_var_cnt (d); + size_t n_vars = dict_get_n_vars (dict); + struct case_map_stage *stage; size_t i; - for (i = 0; i < var_cnt; i++) + stage = xmalloc (sizeof *stage); + stage->dict = dict; + hmap_init (&stage->stage_vars); + + for (i = 0; i < n_vars; i++) { - struct variable *v = dict_get_var (d, i); - int *src_fv = xmalloc (sizeof *src_fv); - *src_fv = var_get_case_index (v); - var_attach_aux (v, src_fv, var_dtor_free); + const struct variable *var = dict_get_var (dict, i); + struct stage_var *stage_var; + + stage_var = xmalloc (sizeof *stage_var); + stage_var->var = var; + stage_var->case_index = var_get_case_index (var); + hmap_insert (&stage->stage_vars, &stage_var->hmap_node, + hash_pointer (var, 0)); } + + return stage; } -/* Produces a case map from dictionary D, which must have been - previously prepared with case_map_prepare_dict(). +/* Destroys STAGE, which was created by case_map_stage_create(). */ +void +case_map_stage_destroy (struct case_map_stage *stage) +{ + if (stage != NULL) + { + struct stage_var *stage_var, *next_stage_var; - Does not retain any reference to D, and clears the aux members - set up by case_map_prepare_dict(). + HMAP_FOR_EACH_SAFE (stage_var, next_stage_var, + struct stage_var, hmap_node, &stage->stage_vars) + { + hmap_delete (&stage->stage_vars, &stage_var->hmap_node); + free (stage_var); + } + hmap_destroy (&stage->stage_vars); + free (stage); + } +} + +static const struct stage_var * +case_map_stage_find_var (const struct case_map_stage *stage, + const struct variable *var) +{ + const struct stage_var *stage_var; + + HMAP_FOR_EACH_IN_BUCKET (stage_var, struct stage_var, hmap_node, + hash_pointer (var, 0), &stage->stage_vars) + if (stage_var->var == var) + return stage_var; + + /* If the following assertion is reached, it indicates a bug in the + case_map_stage client: the client allowed a new variable to be added to + the dictionary. This is not allowed, because of the risk that the new + varaible might have the same address as an old variable that has been + deleted. */ + NOT_REACHED (); +} + +/* Produces a case map from STAGE, which must have been previously created with + case_map_stage_create(). The case map maps from the original case index of + the variables in STAGE's dictionary to their current case indexes. - Returns the new case map, or a null pointer if no mapping is - required (that is, no data has changed position). */ + Returns the new case map, or a null pointer if no mapping is required (that + is, no data has changed position). */ struct case_map * -case_map_from_dict (const struct dictionary *d) +case_map_stage_get_case_map (const struct case_map_stage *stage) { struct case_map *map; - size_t var_cnt = dict_get_var_cnt (d); + size_t n_vars = dict_get_n_vars (stage->dict); size_t n_values; size_t i; bool identity_map = true; - map = create_case_map (dict_get_proto (d)); - for (i = 0; i < var_cnt; i++) + map = create_case_map (dict_get_proto (stage->dict)); + for (i = 0; i < n_vars; i++) { - struct variable *v = dict_get_var (d, i); - int *src_fv = var_detach_aux (v); + const struct variable *var = dict_get_var (stage->dict, i); + const struct stage_var *stage_var = case_map_stage_find_var (stage, var); - if (var_get_case_index (v) != *src_fv) + if (var_get_case_index (var) != stage_var->case_index) identity_map = false; - insert_mapping (map, *src_fv, var_get_case_index (v)); - - free (src_fv); + insert_mapping (map, stage_var->case_index, var_get_case_index (var)); } if (identity_map) @@ -283,12 +343,9 @@ struct case_map * case_map_by_name (const struct dictionary *old, const struct dictionary *new) { - struct case_map *map; - size_t var_cnt = dict_get_var_cnt (new); - size_t i; - - map = create_case_map (dict_get_proto (new)); - for (i = 0; i < var_cnt; i++) + size_t n_vars = dict_get_n_vars (new); + struct case_map *map = create_case_map (dict_get_proto (new)); + for (size_t i = 0; i < n_vars; i++) { struct variable *nv = dict_get_var (new, i); struct variable *ov = dict_lookup_var_assert (old, var_get_name (nv)); @@ -304,6 +361,6 @@ void case_map_dump (const struct case_map *cm) { int i; - for (i = 0 ; i < caseproto_get_n_widths (cm->proto); ++i ) + for (i = 0 ; i < caseproto_get_n_widths (cm->proto); ++i) printf ("%d -> %d\n", i, cm->map[i]); }