void record_manager::sync()
{
// Critical Section
///////////////////////////////////////////////////////////////////////////
ALLOCATE_WRITE(mutex_);
write_count();
///////////////////////////////////////////////////////////////////////////
}
void record_manager::create()
{
// Critical Section
///////////////////////////////////////////////////////////////////////////
ALLOCATE_WRITE(mutex_);
if (record_count_ != 0)
throw std::runtime_error("Existing file record count is nonzero.");
file_.resize(header_size_ + record_to_position(record_count_));
write_count();
///////////////////////////////////////////////////////////////////////////
}
static void
write_count(pccluster t, size_t * clusters, size_t * coeffs)
{
uint i;
/* Increase cluster counter */
(*clusters)++;
/* Add number of coefficients of transfer matrix */
(*coeffs) += 2 * t->dim;
/* Handle sons */
for (i = 0; i < t->sons; i++)
write_count(t->son[i], clusters, coeffs);
}
/*
* Finalize a hash
*/
void MDx_HashFunction::final_result(uint8_t output[])
{
m_buffer[m_position] = (BIG_BIT_ENDIAN ? 0x80 : 0x01);
for(size_t i = m_position+1; i != m_buffer.size(); ++i)
m_buffer[i] = 0;
if(m_position >= m_buffer.size() - COUNT_SIZE)
{
compress_n(m_buffer.data(), 1);
zeroise(m_buffer);
}
write_count(&m_buffer[m_buffer.size() - COUNT_SIZE]);
compress_n(m_buffer.data(), 1);
copy_out(output);
clear();
}
int
main ()
{
char c;
char *line, *buffer, *tmp, *x;
int i, linelen, nothree;
long buflen, seqlen;
line = malloc (256);
if (!line)
return -1;
seqlen = 0;
nothree = 1;
while (nothree && fgets (line, 255, stdin))
if (line[0] == '>' && line[1] == 'T' && line[2] == 'H')
nothree = 0;
free (line);
buflen = 10240;
buffer = malloc (buflen + 1);
if (!buffer)
return -1;
x = buffer;
while (fgets (x, 255, stdin))
{
linelen = strlen (x);
if (linelen)
{
if (x[linelen - 1] == '\n')
linelen--;
c = x[0];
if (c == '>')
break;
else if (c != ';')
{
seqlen = seqlen + linelen;
if (seqlen + 512 >= buflen)
{
buflen = buflen + 10240;
tmp = realloc (buffer, buflen + 1);
if (tmp == NULL)
return -1;
buffer = tmp;
x = &(buffer[seqlen]);
}
else
x = &(x[linelen]);
x[0] = 0;
}
}
}
for (i = 0; i < seqlen; i++)
buffer[i] = toupper (buffer[i]);
write_frequencies (1, buffer, seqlen);
write_frequencies (2, buffer, seqlen);
write_count ("GGT", buffer, seqlen);
write_count ("GGTA", buffer, seqlen);
write_count ("GGTATT", buffer, seqlen);
write_count ("GGTATTTTAATT", buffer, seqlen);
write_count ("GGTATTTTAATTTATAGT", buffer, seqlen);
free (buffer);
return 0;
}
void
write_cdf_cluster(pccluster t, const char *name)
{
size_t clusters, clusteridx;
size_t coeffs, coeffidx;
int nc_file, nc_sons, nc_size, nc_idx, nc_coeff;
int nc_clusters, nc_coeffs, nc_totalsize, nc_dim;
int result;
/* Count number of clusters and coefficients */
clusters = 0;
coeffs = 0;
write_count(t, &clusters, &coeffs);
/* Create NetCDF file */
result = nc_create(name, NC_64BIT_OFFSET, &nc_file);
assert(result == NC_NOERR);
/* Define "clusters" dimension */
result = nc_def_dim(nc_file, "clusters", clusters, &nc_clusters);
assert(result == NC_NOERR);
/* Define "coeffs" dimension */
result = nc_def_dim(nc_file, "coeffs", coeffs, &nc_coeffs);
assert(result == NC_NOERR);
/* Define "totalsize" dimension */
result = nc_def_dim(nc_file, "totalsize", t->size, &nc_totalsize);
assert(result == NC_NOERR);
/* Define "dim" dimension */
result = nc_def_dim(nc_file, "dim", t->dim, &nc_dim);
assert(result == NC_NOERR);
/* Define "sons" variable */
result = nc_def_var(nc_file, "sons", NC_INT, 1, &nc_clusters, &nc_sons);
assert(result == NC_NOERR);
/* Define "size" variable */
result = nc_def_var(nc_file, "size", NC_INT, 1, &nc_clusters, &nc_size);
assert(result == NC_NOERR);
/* Define "idx" variable */
result = nc_def_var(nc_file, "idx", NC_INT, 1, &nc_totalsize, &nc_idx);
assert(result == NC_NOERR);
/* Define "coeff" variable */
result = nc_def_var(nc_file, "coeff", NC_DOUBLE, 1, &nc_coeffs, &nc_coeff);
assert(result == NC_NOERR);
/* Finish NetCDF define mode */
result = nc_enddef(nc_file);
assert(result == NC_NOERR);
/* Write index to NetCDF variable */
result = nc_put_var(nc_file, nc_idx, t->idx);
/* Write coefficiens to NetCDF variables */
clusteridx = 0;
coeffidx = 0;
write_cdf(t, clusters, coeffs, &clusteridx, &coeffidx,
nc_file, nc_sons, nc_size, nc_coeff);
assert(clusteridx == clusters);
assert(coeffidx == coeffs);
/* Close file */
result = nc_close(nc_file);
assert(result == NC_NOERR);
}
void
write_cdfpart_cluster(pccluster t, int nc_file, const char *prefix)
{
size_t clusters, clusteridx;
size_t coeffs, coeffidx;
char *buf;
int bufsize;
int nc_sons, nc_size, nc_idx, nc_coeff;
int nc_clusters, nc_coeffs, nc_totalsize, nc_dim;
int result;
/* Prepare buffer for prefixed names */
bufsize = strlen(prefix) + 16;
buf = (char *) allocmem(sizeof(char) * bufsize);
/* Count number of clusters and coefficients */
clusters = 0;
coeffs = 0;
write_count(t, &clusters, &coeffs);
/* Switch NetCDF file to define mode */
result = nc_redef(nc_file);
assert(result == NC_NOERR || result == NC_EINDEFINE);
/* Define "clusters" dimension */
prefix_name(buf, bufsize, prefix, "clusters");
result = nc_def_dim(nc_file, buf, clusters, &nc_clusters);
assert(result == NC_NOERR);
/* Define "coeffs" dimension */
prefix_name(buf, bufsize, prefix, "coeffs");
result = nc_def_dim(nc_file, buf, coeffs, &nc_coeffs);
assert(result == NC_NOERR);
/* Define "totalsize" dimension */
prefix_name(buf, bufsize, prefix, "totalsize");
result = nc_def_dim(nc_file, buf, t->size, &nc_totalsize);
assert(result == NC_NOERR);
/* Define "dim" dimension */
prefix_name(buf, bufsize, prefix, "dim");
result = nc_def_dim(nc_file, buf, t->dim, &nc_dim);
assert(result == NC_NOERR);
/* Define "sons" variable */
prefix_name(buf, bufsize, prefix, "sons");
result = nc_def_var(nc_file, buf, NC_INT, 1, &nc_clusters, &nc_sons);
assert(result == NC_NOERR);
/* Define "size" variable */
prefix_name(buf, bufsize, prefix, "size");
result = nc_def_var(nc_file, buf, NC_INT, 1, &nc_clusters, &nc_size);
assert(result == NC_NOERR);
/* Define "idx" variable */
prefix_name(buf, bufsize, prefix, "idx");
result = nc_def_var(nc_file, buf, NC_INT, 1, &nc_totalsize, &nc_idx);
assert(result == NC_NOERR);
/* Define "coeff" variable */
prefix_name(buf, bufsize, prefix, "coeff");
result = nc_def_var(nc_file, buf, NC_DOUBLE, 1, &nc_coeffs, &nc_coeff);
assert(result == NC_NOERR);
/* Finish NetCDF define mode */
result = nc_enddef(nc_file);
assert(result == NC_NOERR);
/* Write index to NetCDF variable */
result = nc_put_var(nc_file, nc_idx, t->idx);
/* Write coefficiencs to NetCDF variables */
clusteridx = 0;
coeffidx = 0;
write_cdf(t, clusters, coeffs, &clusteridx, &coeffidx,
nc_file, nc_sons, nc_size, nc_coeff);
assert(clusteridx == clusters);
assert(coeffidx == coeffs);
/* Clean up */
nc_sync(nc_file);
freemem(buf);
}
