static int bssm_model_read(GthBSSMModel *bssm_model, FILE *file, GtError *err) { int had_err = 0; gt_error_check(err); gt_xfread(&bssm_model->hypothesis_num, sizeof (GtUword), 1, file); if (bssm_model->hypothesis_num != HYPOTHESIS7 && bssm_model->hypothesis_num != HYPOTHESIS2) { gt_error_set(err, "BSSM model contains unknown hypothesis number"); had_err = -1; } if (!had_err) { gt_xfread(&bssm_model->window_size_left, sizeof (GtUword), 1, file); gt_xfread(&bssm_model->window_size_right, sizeof (GtUword), 1, file); switch (bssm_model->hypothesis_num) { case HYPOTHESIS2: gt_xfread(&bssm_model->hypotables.hypo2table, sizeof (Hypo2table), 1, file); break; case HYPOTHESIS7: gt_xfread(&bssm_model->hypotables.hypo7table, sizeof (Hypo7table), 1, file); break; default: gt_assert(0); } } return had_err; }
static GthBSSMParam* load_old_binary_format(GtStr *path, const char *filename, GtError *err) { GthBSSMParam *bssm_param; int had_err = 0; FILE *file; gt_error_check(err); gt_assert(path && filename); file = gt_xfopen(gt_str_get(path), "r"); /* read version number and check if equals version number 2 */ bssm_param = gt_malloc(sizeof *bssm_param); gt_xfread(&bssm_param->version_num, sizeof (unsigned char), 1, file); if (bssm_param->version_num != (unsigned char) 2) { gt_error_set(err, "BSSM file %s has unrecognized version number %u", filename, bssm_param->version_num); had_err = -1; } if (!had_err) { /* read in model variables */ gt_xfread(&bssm_param->gt_donor_model_set, sizeof (bool), 1, file); gt_xfread(&bssm_param->gc_donor_model_set, sizeof (bool), 1, file); gt_xfread(&bssm_param->ag_acceptor_model_set, sizeof (bool), 1, file); /* check if at least one model is set in file */ if (!bssm_param->gt_donor_model_set && !bssm_param->gc_donor_model_set && !bssm_param->ag_acceptor_model_set) { gt_error_set(err, "BSSM file %s apparently contains no model", filename); had_err = -1; } } /* read GT donor site model */ if (!had_err && bssm_param->gt_donor_model_set) had_err = bssm_model_read(&bssm_param->gt_donor_model, file, err); /* read GC donor site model */ if (!had_err && bssm_param->gc_donor_model_set) had_err = bssm_model_read(&bssm_param->gc_donor_model, file, err); /* read AG acceptor site model */ if (!had_err && bssm_param->ag_acceptor_model_set) had_err = bssm_model_read(&bssm_param->ag_acceptor_model, file, err); gt_xfclose(file); if (had_err) { gth_bssm_param_delete(bssm_param); return NULL; } return bssm_param; }
/* FIXME: convert to platform-independent variant */ struct seqRangeList * SRLReadFromStream(FILE *fp, const MRAEnc *alphabet, enum SRLFeatures features, GT_UNUSED GtError *err) { struct seqRangeList *newRangeList; size_t numRanges; gt_assert(fp && err); newRangeList = gt_malloc(sizeof (struct seqRangeList)); newRangeList->alphabet = alphabet; newRangeList->symBits = requiredSymbolBits(MRAEncGetSize(alphabet) - 1); if (newRangeList->symBits) newRangeList->maxRangeLen = (((Seqpos)1) << (symLenStrBits - newRangeList->symBits)) - 1; else newRangeList->maxRangeLen = ~(Seqpos)0; gt_xfread(&(newRangeList->numRanges), sizeof (newRangeList->numRanges), 1, fp); numRanges = newRangeList->numRanges; newRangeList->partialSymSums = NULL; newRangeList->ranges = gt_malloc(sizeof (struct seqRange) * (newRangeList->numRangesStorable = numRanges)); gt_xfread(newRangeList->ranges, sizeof (struct seqRange), numRanges, fp); if (features & SRL_PARTIAL_SYMBOL_SUMS) { Seqpos *partialSymSums; size_t numSyms = MRAEncGetSize(alphabet), i; newRangeList->partialSymSums = partialSymSums = gt_malloc(sizeof (Seqpos) * MRAEncGetSize(alphabet) * numRanges); memset(partialSymSums, 0, sizeof (Seqpos) * numSyms); for (i = 1; i < numRanges; ++i) { struct seqRange *lastRange = newRangeList->ranges + i - 1; Symbol lastSym = seqRangeSym(lastRange, newRangeList->symBits); memcpy(partialSymSums + i * numSyms, partialSymSums + (i - 1) * numSyms, sizeof (Seqpos) * numSyms); partialSymSums[i * numSyms + lastSym] += seqRangeLen(lastRange, newRangeList->symBits); } } return newRangeList; }
int gt_file_xread(GtFile *file, void *buf, size_t nbytes) { int rval = -1; if (file) { switch (file->mode) { case GT_FILE_MODE_UNCOMPRESSED: rval = gt_xfread(buf, 1, nbytes, file->fileptr.file); break; case GT_FILE_MODE_GZIP: rval = gt_xgzread(file->fileptr.gzfile, buf, nbytes); break; case GT_FILE_MODE_BZIP2: rval = gt_xbzread(file->fileptr.bzfile, buf, nbytes); break; default: gt_assert(0); } } else rval = gt_xfread(buf, 1, nbytes, stdin); return rval; }
static int gt_compressedbits_runner(GT_UNUSED int argc, GT_UNUSED const char **argv, GT_UNUSED int parsed_args, void *tool_arguments, GtError *err) { GtCompressdbitsArguments *arguments = tool_arguments; int had_err = 0; unsigned long idx; unsigned long long num_of_bits = 0ULL; GtBitsequence *bits = NULL; GtCompressedBitsequence *cbs = NULL, *read_cbs = NULL; GtStr *filename = gt_str_new(); FILE *fp = NULL; gt_error_check(err); gt_assert(arguments); gt_assert(argc == parsed_args); if (gt_option_is_set(arguments->filename_op)) { FILE *file = NULL; gt_assert(arguments->filename != NULL); file = gt_xfopen(gt_str_get(arguments->filename), "r"); if ((size_t) 1 != gt_xfread(&num_of_bits, sizeof (num_of_bits), (size_t) 1, file)) { had_err = -1; } if (!had_err) { gt_log_log("bits to read: %llu", num_of_bits); arguments->size = (unsigned long) GT_NUMOFINTSFORBITS(num_of_bits); bits = gt_malloc(sizeof (*bits) * arguments->size); if ((size_t) arguments->size != gt_xfread(bits, sizeof (*bits), (size_t) arguments->size, file)) { had_err = -1; } } gt_xfclose(file); } else { bits = gt_calloc(sizeof (*bits), (size_t) arguments->size); num_of_bits = (unsigned long long) (GT_INTWORDSIZE * arguments->size); if (arguments->fill_random) { for (idx = 0; idx < arguments->size; idx++) { bits[idx] = (GtBitsequence) (0xAAAAAAAAAAAAAAAAUL ^ gt_rand_max(ULONG_MAX)); } } else { for (idx = 0; idx < arguments->size; idx++) bits[idx] = (GtBitsequence) (0xAAAAAAAAAAAAAAAAUL ^ idx); } } if (!had_err) { fp = gt_xtmpfp(filename); gt_fa_xfclose(fp); fp = NULL; gt_log_log("filename: %s", gt_str_get(filename)); gt_log_log("size in words: %lu", arguments->size); cbs = gt_compressed_bitsequence_new( bits, arguments->samplerate, (unsigned long) num_of_bits); gt_log_log("original size in MB: %2.3f", (sizeof (*bits) * arguments->size) / (1024.0 * 1024.0)); gt_log_log("compressed size in MB: %2.3f", gt_compressed_bitsequence_size(cbs) / (1024.0 * 1024.0)); gt_log_log("popcount table size thereof in MB: %2.3f", gt_popcount_tab_calculate_size(15U) / (1024.0 * 1024.0)); had_err = gt_compressed_bitsequence_write(cbs, gt_str_get(filename), err); } if (!had_err) { read_cbs = gt_compressed_bitsequence_new_from_file(gt_str_get(filename), err); if (read_cbs == NULL) had_err = -1; } if (!had_err && bits != NULL && arguments->check_consistency) { for (idx = 0; (unsigned long long) idx < num_of_bits; ++idx) { int GT_UNUSED bit = gt_compressed_bitsequence_access(read_cbs, idx); int GT_UNUSED original = GT_ISIBITSET(bits, idx) ? 1 : 0; gt_assert(gt_compressed_bitsequence_access(cbs, idx) == bit); gt_assert(original == bit); } } gt_compressed_bitsequence_delete(cbs); gt_compressed_bitsequence_delete(read_cbs); gt_free(bits); gt_str_delete(filename); return had_err; }