static int gt_gff3validator_runner(int argc, const char **argv, int parsed_args, void *tool_arguments, GtError *err) { GFF3ValidatorArguments *arguments = tool_arguments; GtTypeChecker *type_checker = NULL; GtXRFChecker *xrf_checker = NULL; GtNodeStream *gff3_in_stream; int had_err = 0; gt_error_check(err); gt_assert(arguments); /* create a GFF3 input stream */ gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args, argv + parsed_args); gt_gff3_in_stream_check_id_attributes((GtGFF3InStream*) gff3_in_stream); /* set different type checker if necessary */ if (gt_typecheck_info_option_used(arguments->tci)) { type_checker = gt_typecheck_info_create_type_checker(arguments->tci, err); if (!type_checker) had_err = -1; if (!had_err) gt_gff3_in_stream_set_type_checker(gff3_in_stream, type_checker); } /* set XRF checker */ if (gt_xrfcheck_info_option_used(arguments->xci)) { xrf_checker = gt_xrfcheck_info_create_xrf_checker(arguments->xci, err); if (!xrf_checker) had_err = -1; if (!had_err) gt_gff3_in_stream_set_xrf_checker(gff3_in_stream, xrf_checker); } /* enable strict mode (if necessary) */ if (!had_err && arguments->strict) gt_gff3_in_stream_enable_strict_mode((GtGFF3InStream*) gff3_in_stream); /* pull the features through the stream and free them afterwards */ if (!had_err) had_err = gt_node_stream_pull(gff3_in_stream, err); if (!had_err) printf("input is valid GFF3\n"); /* free */ gt_node_stream_delete(gff3_in_stream); gt_type_checker_delete(type_checker); gt_xrf_checker_delete(xrf_checker); return had_err; }
static int gt_gff3_runner(int argc, const char **argv, int parsed_args, void *tool_arguments, GtError *err) { GFF3Arguments *arguments = tool_arguments; GtTypeChecker *type_checker = NULL; GtNodeStream *gff3_in_stream, *sort_stream = NULL, *load_stream = NULL, *merge_feature_stream = NULL, *add_introns_stream = NULL, *set_source_stream = NULL, *gff3_out_stream = NULL, *last_stream; int had_err = 0; gt_error_check(err); gt_assert(arguments); /* create a gff3 input stream */ gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args, argv + parsed_args); if (arguments->verbose && arguments->outfp) gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream); if (arguments->checkids) gt_gff3_in_stream_check_id_attributes((GtGFF3InStream*) gff3_in_stream); if (!arguments->addids) gt_gff3_in_stream_disable_add_ids(gff3_in_stream); last_stream = gff3_in_stream; /* set different type checker if necessary */ if (gt_typecheck_info_option_used(arguments->tci)) { type_checker = gt_typecheck_info_create_type_checker(arguments->tci, err); if (!type_checker) had_err = -1; if (!had_err) gt_gff3_in_stream_set_type_checker(gff3_in_stream, type_checker); } /* set offset (if necessary) */ if (!had_err && arguments->offset != GT_UNDEF_WORD) gt_gff3_in_stream_set_offset(gff3_in_stream, arguments->offset); /* set offsetfile (if necessary) */ if (!had_err && gt_str_length(arguments->offsetfile)) { had_err = gt_gff3_in_stream_set_offsetfile(gff3_in_stream, arguments->offsetfile, err); } /* enable strict mode (if necessary) */ if (!had_err && arguments->strict) gt_gff3_in_stream_enable_strict_mode((GtGFF3InStream*) gff3_in_stream); /* enable tidy mode (if necessary) */ if (!had_err && arguments->tidy) gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream); if (!had_err && arguments->fixboundaries) gt_gff3_in_stream_fix_region_boundaries((GtGFF3InStream*) gff3_in_stream); /* create load stream (if necessary) */ if (!had_err && arguments->load) { load_stream = gt_load_stream_new(last_stream); last_stream = load_stream; } /* create sort stream (if necessary) */ if (!had_err && arguments->sort) { sort_stream = gt_sort_stream_new(last_stream); last_stream = sort_stream; } /* create merge feature stream (if necessary) */ if (!had_err && arguments->mergefeat) { gt_assert(sort_stream); merge_feature_stream = gt_merge_feature_stream_new(sort_stream); last_stream = merge_feature_stream; } /* create addintrons stream (if necessary) */ if (!had_err && arguments->addintrons) { gt_assert(last_stream); add_introns_stream = gt_add_introns_stream_new(last_stream); last_stream = add_introns_stream; } /* create setsource stream (if necessary) */ if (!had_err && gt_str_length(arguments->newsource) > 0) { gt_assert(last_stream); GtNodeVisitor *ssv = gt_set_source_visitor_new(arguments->newsource); set_source_stream = gt_visitor_stream_new(last_stream, ssv); last_stream = set_source_stream; } /* create gff3 output stream */ if (!had_err && arguments->show) { gff3_out_stream = gt_gff3_out_stream_new(last_stream, arguments->outfp); last_stream = gff3_out_stream; gt_gff3_out_stream_set_fasta_width((GtGFF3OutStream*) last_stream, arguments->width); if (arguments->retainids) gt_gff3_out_stream_retain_id_attributes((GtGFF3OutStream*) last_stream); } /* pull the features through the stream and free them afterwards */ if (!had_err) had_err = gt_node_stream_pull(last_stream, err); /* free */ gt_node_stream_delete(gff3_out_stream); gt_node_stream_delete(sort_stream); gt_node_stream_delete(load_stream); gt_node_stream_delete(merge_feature_stream); gt_node_stream_delete(add_introns_stream); gt_node_stream_delete(set_source_stream); gt_node_stream_delete(gff3_in_stream); gt_type_checker_delete(type_checker); return had_err; }
static int gt_speck_runner(int argc, const char **argv, int parsed_args, void *tool_arguments, GtError *err) { GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL, *a_in_stream = NULL, *a_out_stream = NULL, *feature_stream = NULL, *sort_stream = NULL, *last_stream = NULL; GtNodeVisitor *spec_visitor = NULL; GtSpecResults *res = NULL; GtFeatureIndex *fi = NULL; GtTypeChecker *type_checker = NULL; GtTimer *t = NULL; GtRegionMapping *rm = NULL; GtArray *arr = gt_array_new(sizeof (GtFeatureNode*)); GtStr *prog, *speclib; SpeccheckArguments *arguments = tool_arguments; int had_err = 0; gt_error_check(err); res = gt_spec_results_new(); gt_assert(res); if (gt_file_exists(gt_str_get(arguments->format))) { speclib = gt_str_ref(arguments->format); } else { prog = gt_str_new(); gt_str_append_cstr_nt(prog, gt_error_get_progname(err), gt_cstr_length_up_to_char(gt_error_get_progname(err), ' ')); speclib = gt_get_gtdata_path(gt_str_get(prog), NULL); gt_str_delete(prog); gt_str_append_cstr(speclib, "/spec/output_drivers/"); gt_str_append_str(speclib, arguments->format); if (!gt_file_exists(gt_str_get(speclib))) { gt_error_set(err, "output driver file \"%s\" does not exist", gt_str_get(speclib)); had_err = -1; } } if (!had_err) { spec_visitor = gt_spec_visitor_new(gt_str_get(arguments->specfile), res, err); if (!spec_visitor) { gt_spec_results_delete(res); return -1; } } t = gt_timer_new(); gt_assert(t); /* add region mapping if given */ if (!had_err && gt_seqid2file_option_used(arguments->s2fi)) { rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err); if (!rm) had_err = -1; if (!had_err) gt_spec_visitor_add_region_mapping((GtSpecVisitor*) spec_visitor, rm); } /* set type checker if necessary */ if (!had_err && gt_typecheck_info_option_used(arguments->tci)) { type_checker = gt_typecheck_info_create_type_checker(arguments->tci, err); if (!type_checker) had_err = -1; if (!had_err) gt_spec_visitor_add_type_checker((GtSpecVisitor*) spec_visitor, type_checker); } if (!had_err) { /* set runtime error behaviour */ if (arguments->fail_hard) gt_spec_visitor_fail_on_runtime_error((GtSpecVisitor*) spec_visitor); else gt_spec_visitor_report_runtime_errors((GtSpecVisitor*) spec_visitor); /* redirect warnings */ gt_warning_set_handler(gt_speck_record_warning, res); last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted( argc - parsed_args, argv + parsed_args); gt_assert(gff3_in_stream); gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream); /* insert sort stream if requested */ if (arguments->sort) { last_stream = sort_stream = gt_sort_stream_new(last_stream); } /* if -provideindex is given, collect input features and index them first */ if (arguments->provideindex) { fi = gt_feature_index_memory_new(); gt_assert(fi); last_stream = feature_stream = gt_feature_stream_new(last_stream, fi); gt_assert(feature_stream); last_stream = a_out_stream = gt_array_out_stream_all_new(last_stream, arr, err); if (!a_out_stream) had_err = -1; gt_timer_start(t); if (!had_err) had_err = gt_node_stream_pull(last_stream, err); if (!had_err) { gt_spec_visitor_add_feature_index((GtSpecVisitor*) spec_visitor, gt_feature_index_ref(fi)); last_stream = a_in_stream = gt_array_in_stream_new(arr, NULL, err); if (!a_in_stream) had_err = -1; } } else { gt_timer_start(t); } if (!had_err) { checker_stream = gt_visitor_stream_new(last_stream, spec_visitor); gt_assert(checker_stream); } /* perform checking */ if (!had_err) had_err = gt_node_stream_pull(checker_stream, err); gt_timer_stop(t); /* reset warnings output */ gt_warning_set_handler(gt_warning_default_handler, NULL); /* output results */ if (!had_err) { GtStr *runtime = gt_str_new(); gt_timer_get_formatted(t, GT_WD ".%06ld", runtime); had_err = gt_spec_results_render_template(res, gt_str_get(speclib), arguments->outfp, gt_str_get(arguments->specfile), arguments->verbose, arguments->colored, gt_str_get(runtime), err); gt_str_delete(runtime); } } /* free */ gt_node_stream_delete(gff3_in_stream); gt_node_stream_delete(a_in_stream); gt_node_stream_delete(a_out_stream); gt_node_stream_delete(checker_stream); gt_node_stream_delete(feature_stream); gt_node_stream_delete(sort_stream); gt_spec_results_delete(res); gt_feature_index_delete(fi); gt_type_checker_delete(type_checker); gt_timer_delete(t); gt_array_delete(arr); gt_str_delete(speclib); return had_err; }