bool
casereader_read (struct casereader *reader, struct ccase *c)
{
- if (reader->case_cnt != 0 && reader->class->read (reader, reader->aux, c))
+ if (reader->case_cnt != 0)
{
- assert (case_get_value_cnt (c) >= reader->value_cnt);
+ /* ->read may use casereader_swap to replace itself by
+ another reader and then delegate to that reader by
+ recursively calling casereader_read. Currently only
+ lazy_casereader does this and, with luck, nothing else
+ ever will.
+
+ To allow this to work, however, we must decrement
+ case_cnt before calling ->read. If we decremented
+ case_cnt after calling ->read, then this would actually
+ drop two cases from case_cnt instead of one, and we'd
+ lose the last case in the casereader. */
if (reader->case_cnt != CASENUMBER_MAX)
reader->case_cnt--;
- return true;
- }
- else
- {
- reader->case_cnt = 0;
- case_nullify (c);
- return false;
+ if (reader->class->read (reader, reader->aux, c))
+ {
+ assert (case_get_value_cnt (c) >= reader->value_cnt);
+ return true;
+ }
}
+ reader->case_cnt = 0;
+ case_nullify (c);
+ return false;
}
/* Destroys READER.
return false;
}
+/* Returns true if no cases remain to be read from READER, or if
+ an error has occurred on READER. (A return value of false
+ does *not* mean that the next call to casereader_peek or
+ casereader_read will return true, because an error can occur
+ in the meantime.) */
+bool
+casereader_is_empty (struct casereader *reader)
+{
+ struct ccase c;
+ if (reader->case_cnt == 0 || !casereader_peek (reader, 0, &c))
+ return true;
+ else
+ {
+ case_destroy (&c);
+ return false;
+ }
+}
+
/* Returns true if an I/O error or another hard error has
occurred on READER, a clone of READER, or on some object on
which READER's data has a dependency, false otherwise. */
reader->aux = aux;
return reader;
}
+
+/* If READER is a casereader of the given CLASS, returns its
+ associated auxiliary data; otherwise, returns a null pointer.
+
+ This function is intended for use from casereader
+ implementations, not by casereader users. Even within
+ casereader implementations, its usefulness is quite limited,
+ for at least two reasons. First, every casereader member
+ function already receives a pointer to the casereader's
+ auxiliary data. Second, a casereader's class can change
+ (through a call to casereader_swap) and this is in practice
+ quite common (e.g. any call to casereader_clone on a
+ casereader that does not directly support clone will cause the
+ casereader to be replaced by a shim caseader). */
+void *
+casereader_dynamic_cast (struct casereader *reader,
+ const struct casereader_class *class)
+{
+ return reader->class == class ? reader->aux : NULL;
+}
\f
/* Random-access casereader implementation.
void *aux;
};
-static struct casereader_class random_reader_casereader_class;
+static const struct casereader_class random_reader_casereader_class;
/* Creates and returns a new random_reader with the given SHARED
data and OFFSET. Inserts the new random reader into the
}
/* Casereader class for random reader. */
-static struct casereader_class random_reader_casereader_class =
+static const struct casereader_class random_reader_casereader_class =
{
random_reader_read,
random_reader_destroy,
struct casereader *subreader; /* Subordinate casereader. */
};
-static struct casereader_random_class shim_class;
+static const struct casereader_random_class shim_class;
/* Interposes a buffering shim atop READER. */
static void
}
/* Class for the buffered reader. */
-static struct casereader_random_class shim_class =
+static const struct casereader_random_class shim_class =
{
shim_read,
shim_destroy,