X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fscratch-writer.c;h=d8263df81ba2d72072d41072f7c8a14de81df8cb;hb=f5c108becd49d78f4898cab11352291f5689d24e;hp=42e77aa7b47869f5483c542f68142e4892cf541a;hpb=480a0746507ce73d26f528b56dc3ed80195096e0;p=pspp diff --git a/src/data/scratch-writer.c b/src/data/scratch-writer.c index 42e77aa7b4..d8263df81b 100644 --- a/src/data/scratch-writer.c +++ b/src/data/scratch-writer.c @@ -17,51 +17,59 @@ 02110-1301, USA. */ #include + #include "scratch-writer.h" + #include -#include "case.h" -#include "casefile.h" -#include "fastfile.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; 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_compacting_would_shrink (scratch_dict)) + if (dict_compacting_would_shrink (scratch_dict)) { compactor = dict_make_compactor (scratch_dict); dict_compact_values (scratch_dict); @@ -72,50 +80,57 @@ scratch_writer_open (struct file_handle *fh, /* Create new contents. */ sh = xmalloc (sizeof *sh); sh->dictionary = scratch_dict; - sh->casefile = fastfile_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_get_next_value_idx ( + scratch_dict)); fh_set_scratch_handle (fh, sh); - return writer; + casewriter = casewriter_create (&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); + 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, + };