/* PSPP - a program for statistical analysis.
- Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2007, 2009, 2010, 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
{
struct taint *taint; /* Corrupted? */
struct caseproto *proto; /* Format of contained cases. */
- casenumber case_cnt; /* Number of cases,
+ casenumber n_cases; /* Number of cases,
CASENUMBER_MAX if unknown. */
const struct casereader_class *class; /* Class. */
void *aux; /* Auxiliary data for class. */
struct ccase *
casereader_read (struct casereader *reader)
{
- if (reader->case_cnt != 0)
+ if (reader->n_cases != 0)
{
/* ->read may use casereader_swap to replace itself by
another reader and then delegate to that reader by
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
+ n_cases before calling ->read. If we decremented
+ n_cases after calling ->read, then this would actually
+ drop two cases from n_cases instead of one, and we'd
lose the last case in the casereader. */
struct ccase *c;
- if (reader->case_cnt != CASENUMBER_MAX)
- reader->case_cnt--;
+ if (reader->n_cases != CASENUMBER_MAX)
+ reader->n_cases--;
c = reader->class->read (reader, reader->aux);
if (c != NULL)
{
size_t n_widths UNUSED = caseproto_get_n_widths (reader->proto);
- assert (case_get_value_cnt (c) >= n_widths);
+ assert (case_get_n_values (c) >= n_widths);
expensive_assert (caseproto_equal (case_get_proto (c), 0,
reader->proto, 0, n_widths));
return c;
}
}
- reader->case_cnt = 0;
+ reader->n_cases = 0;
return NULL;
}
{
struct casereader *reader = CONST_CAST (struct casereader *, reader_);
struct casereader *clone;
- if ( reader == NULL )
+ if (reader == NULL)
return NULL;
if (reader->class->clone == NULL)
return clone;
}
-/* Makes a copy of ORIGINAL into *NEW1 (if NEW1 is non-null) and
- *NEW2 (if NEW2 is non-null), then destroys ORIGINAL. */
-void
-casereader_split (struct casereader *original,
- struct casereader **new1, struct casereader **new2)
-{
- if (new1 != NULL && new2 != NULL)
- {
- *new1 = casereader_rename (original);
- *new2 = casereader_clone (*new1);
- }
- else if (new1 != NULL)
- *new1 = casereader_rename (original);
- else if (new2 != NULL)
- *new2 = casereader_rename (original);
- else
- casereader_destroy (original);
-}
-
/* Returns a copy of READER, which is itself destroyed.
Useful for taking over ownership of a casereader, to enforce
preventing the original owner from accessing the casereader
struct ccase *
casereader_peek (struct casereader *reader, casenumber idx)
{
- if (idx < reader->case_cnt)
+ if (idx < reader->n_cases)
{
struct ccase *c;
if (reader->class->peek == NULL)
if (c != NULL)
return c;
else if (casereader_error (reader))
- reader->case_cnt = 0;
+ reader->n_cases = 0;
}
- if (reader->case_cnt > idx)
- reader->case_cnt = idx;
+ if (reader->n_cases > idx)
+ reader->n_cases = idx;
return NULL;
}
bool
casereader_is_empty (struct casereader *reader)
{
- if (reader->case_cnt == 0)
+ if (reader->n_cases == 0)
return true;
else
{
actual number of cases in such a casereader, use
casereader_count_cases. */
casenumber
-casereader_get_case_cnt (struct casereader *reader)
+casereader_get_n_cases (struct casereader *reader)
{
- return reader->case_cnt;
+ return reader->n_cases;
}
static casenumber
casenumber
casereader_count_cases (const struct casereader *reader)
{
- if (reader->case_cnt == CASENUMBER_MAX)
+ if (reader->n_cases == CASENUMBER_MAX)
{
struct casereader *reader_rw = CONST_CAST (struct casereader *, reader);
- reader_rw->case_cnt = casereader_count_cases__ (reader, CASENUMBER_MAX);
+ reader_rw->n_cases = casereader_count_cases__ (reader, CASENUMBER_MAX);
}
- return reader->case_cnt;
+ return reader->n_cases;
}
/* Truncates READER to at most N cases. */
"max_cases" member to struct casereader. We could also add a "truncate"
function to the casereader implementation, to allow the casereader to
throw away data that cannot ever be read. */
- if (reader->case_cnt == CASENUMBER_MAX)
- reader->case_cnt = casereader_count_cases__ (reader, n);
- if (reader->case_cnt > n)
- reader->case_cnt = n;
+ if (reader->n_cases == CASENUMBER_MAX)
+ reader->n_cases = casereader_count_cases__ (reader, n);
+ if (reader->n_cases > n)
+ reader->n_cases = n;
}
/* Returns the prototype for the cases in READER. The caller
struct casereader *
casereader_create_sequential (const struct taint *taint,
const struct caseproto *proto,
- casenumber case_cnt,
+ casenumber n_cases,
const struct casereader_class *class, void *aux)
{
struct casereader *reader = xmalloc (sizeof *reader);
reader->taint = taint != NULL ? taint_clone (taint) : taint_create ();
reader->proto = caseproto_ref (proto);
- reader->case_cnt = case_cnt;
+ reader->n_cases = n_cases;
reader->class = class;
reader->aux = aux;
return reader;
member functions and auxiliary data to pass to those member
functions, respectively. */
struct casereader *
-casereader_create_random (const struct caseproto *proto, casenumber case_cnt,
+casereader_create_random (const struct caseproto *proto, casenumber n_cases,
const struct casereader_random_class *class,
void *aux)
{
shared->class = class;
shared->aux = aux;
shared->min_offset = 0;
- return casereader_create_sequential (NULL, proto, case_cnt,
+ return casereader_create_sequential (NULL, proto, n_cases,
&random_reader_casereader_class,
make_random_reader (shared, 0));
}
struct random_reader_shared *shared = br->shared;
return casereader_create_sequential (casereader_get_taint (reader),
reader->proto,
- casereader_get_case_cnt (reader),
+ casereader_get_n_cases (reader),
&random_reader_casereader_class,
make_random_reader (shared,
br->offset));
projects / pspp / blobdiff