X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fscratch-writer.c;h=e085ca1c28e59b7984251037067019add18984e4;hb=130ced32165dc409b1be560d3d7a581a7ba3c5ee;hp=8bedef65677d984c67a2391cc9c47fa598d779ba;hpb=dcf9b154cbcaa35c3d8459a201b77eec8bcb30bd;p=pspp-builds.git diff --git a/src/data/scratch-writer.c b/src/data/scratch-writer.c index 8bedef65..e085ca1c 100644 --- a/src/data/scratch-writer.c +++ b/src/data/scratch-writer.c @@ -1,122 +1,136 @@ -/* PSPP - computes sample statistics. +/* PSPP - a program for statistical analysis. Copyright (C) 2006 Free Software Foundation, Inc. - Written by Ben Pfaff . - 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 the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. + 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 + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301, USA. */ + along with this program. If not, see . */ #include + #include "scratch-writer.h" + #include -#include "case.h" -#include "casefile.h" -#include "dictionary.h" -#include "file-handle-def.h" -#include "scratch-handle.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + #include "xalloc.h" /* A scratch file writer. */ -struct scratch_writer +struct scratch_writer { struct scratch_handle *handle; /* Underlying scratch handle. */ struct file_handle *fh; /* Underlying file handle. */ struct dict_compactor *compactor; /* Compacts into handle->dictionary. */ + struct casewriter *subwriter; /* Data output. */ }; +static struct casewriter_class scratch_writer_casewriter_class; + /* Opens FH, which must have referent type FH_REF_SCRATCH, and returns a scratch_writer for it, or a null pointer on failure. Cases stored in the scratch_writer will be expected - to be drawn from DICTIONARY. - - If you use an any_writer instead, then your code can be more - flexible without being any harder to write. */ -struct scratch_writer * + to be drawn from DICTIONARY. */ +struct casewriter * scratch_writer_open (struct file_handle *fh, - const struct dictionary *dictionary) + const struct dictionary *dictionary) { struct scratch_handle *sh; struct scratch_writer *writer; struct dictionary *scratch_dict; struct dict_compactor *compactor; + struct casewriter *casewriter; + size_t dict_value_cnt; if (!fh_open (fh, FH_REF_SCRATCH, "scratch file", "we")) return NULL; /* Destroy previous contents of handle. */ sh = fh_get_scratch_handle (fh); - if (sh != NULL) + if (sh != NULL) scratch_handle_destroy (sh); /* Copy the dictionary and compact if needed. */ scratch_dict = dict_clone (dictionary); - if (dict_needs_compaction (scratch_dict)) + if (dict_compacting_would_shrink (scratch_dict)) { compactor = dict_make_compactor (scratch_dict); dict_compact_values (scratch_dict); } else compactor = NULL; + dict_value_cnt = dict_get_next_value_idx (scratch_dict); /* Create new contents. */ sh = xmalloc (sizeof *sh); sh->dictionary = scratch_dict; - sh->casefile = casefile_create (dict_get_next_value_idx (sh->dictionary)); + sh->casereader = NULL; /* Create writer. */ writer = xmalloc (sizeof *writer); writer->handle = sh; writer->fh = fh; writer->compactor = compactor; + writer->subwriter = autopaging_writer_create (dict_value_cnt); fh_set_scratch_handle (fh, sh); - return writer; + casewriter = casewriter_create (dict_value_cnt, + &scratch_writer_casewriter_class, writer); + taint_propagate (casewriter_get_taint (writer->subwriter), + casewriter_get_taint (casewriter)); + return casewriter; } /* Writes case C to WRITER. */ -bool -scratch_writer_write_case (struct scratch_writer *writer, - const struct ccase *c) +static void +scratch_writer_casewriter_write (struct casewriter *w UNUSED, void *writer_, + struct ccase *c) { + struct scratch_writer *writer = writer_; struct scratch_handle *handle = writer->handle; - if (writer->compactor) + struct ccase tmp; + if (writer->compactor) { - struct ccase tmp_case; - case_create (&tmp_case, dict_get_next_value_idx (handle->dictionary)); - dict_compactor_compact (writer->compactor, &tmp_case, c); - return casefile_append_xfer (handle->casefile, &tmp_case); + case_create (&tmp, dict_get_next_value_idx (handle->dictionary)); + dict_compactor_compact (writer->compactor, &tmp, c); + case_destroy (c); } - else - return casefile_append (handle->casefile, c); -} - -/* Returns true if an I/O error occurred on WRITER, false otherwise. */ -bool -scratch_writer_error (const struct scratch_writer *writer) -{ - return casefile_error (writer->handle->casefile); + else + case_move (&tmp, c); + casewriter_write (writer->subwriter, &tmp); } -/* Closes WRITER. - Returns true if successful, false if an I/O error occurred on WRITER. */ -bool -scratch_writer_close (struct scratch_writer *writer) +/* Closes WRITER. */ +static void +scratch_writer_casewriter_destroy (struct casewriter *w UNUSED, void *writer_) { - struct casefile *cf = writer->handle->casefile; - bool ok = casefile_error (cf); - casefile_mode_reader (cf); + struct scratch_writer *writer = writer_; + struct casereader *reader = casewriter_make_reader (writer->subwriter); + if (!casereader_error (reader)) + writer->handle->casereader = reader; fh_close (writer->fh, "scratch file", "we"); free (writer); - return ok; } + +static struct casewriter_class scratch_writer_casewriter_class = + { + scratch_writer_casewriter_write, + scratch_writer_casewriter_destroy, + NULL, + };