rc_t prepare_ref_iter( prepare_ctx *ctx,
const VDBManager *vdb_mgr,
VSchema *vdb_schema,
const char * path,
BSTree * regions )
{
rc_t rc = prepare_db_table( ctx, vdb_mgr, vdb_schema, path );
if ( rc == 0 )
{
rc = prepare_reflist( ctx );
if( rc == 0 )
{
if ( ctx->reflist == NULL || count_ref_regions( regions ) == 0 )
{
/* the user has not specified a reference-range : use the whole file... */
rc = prepare_whole_file( ctx );
}
else
{
/* pick only the requested ranges... */
rc = foreach_ref_region( regions, prepare_region_cb, ctx );
}
}
if ( ctx->reflist != NULL )
{
ReferenceList_Release( ctx->reflist );
}
}
VTableRelease ( ctx->seq_tab );
VDatabaseRelease ( ctx->db );
return rc;
}
static rc_t report_ref_database( const VDBManager *vdb_mgr, VFSManager * vfs_mgr, const char * path, bool extended )
{
const VDatabase *db;
rc_t rc = VDBManagerOpenDBRead ( vdb_mgr, &db, NULL, "%s", path );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "VDBManagerOpenDBRead() failed" );
}
else
{
const ReferenceList * reflist;
uint32_t options = ( ereferencelist_usePrimaryIds | ereferencelist_useSecondaryIds | ereferencelist_useEvidenceIds );
rc = ReferenceList_MakeDatabase( &reflist, db, options, 0, NULL, 0 );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "ReferenceList_MakeDatabase() failed" );
}
else
{
uint32_t count;
rc = ReferenceList_Count( reflist, &count );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "ReferenceList_Count() failed" );
}
else
{
rc = KOutMsg( "this object uses %u references\n", count );
if ( rc == 0 )
{
uint32_t idx;
for ( idx = 0; idx < count && rc == 0; ++idx )
{
const ReferenceObj* ref_obj;
rc = ReferenceList_Get( reflist, &ref_obj, idx );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "ReferenceList_Get() failed" );
}
else
{
rc = report_ref_obj( vdb_mgr, vfs_mgr, path, idx, ref_obj, extended );
ReferenceObj_Release( ref_obj );
}
}
}
}
ReferenceList_Release( reflist );
}
VDatabaseRelease( db );
}
return rc;
}
void free_trans_ctx( trans_ctx * ctx )
{
if ( ctx->dir != NULL ) KDirectoryRelease( ctx->dir );
ctx->dir = NULL;
if ( ctx->vdb_mgr != NULL ) VDBManagerRelease( ctx->vdb_mgr );
ctx->vdb_mgr = NULL;
if ( ctx->db != NULL ) VDatabaseRelease ( ctx->db );
ctx->db = NULL;
if ( ctx->ref_list != NULL ) ReferenceList_Release( ctx->ref_list );
ctx->ref_list = NULL;
if ( ctx->almgr != NULL ) AlignMgrRelease ( ctx->almgr );
ctx->almgr = NULL;
}
static rc_t ref_walker_walk_ref_range( struct ref_walker * self, ref_walker_data * rwd )
{
ReferenceIterator * ref_iter;
rc_t rc = AlignMgrMakeReferenceIterator ( self->amgr, &ref_iter, &self->cb_block, self->min_mapq ); /* align/iterator.h */
if ( rc == 0 )
{
/* construct the reference iterator */
uint32_t idx, count;
uint32_t reflist_options = ref_walker_make_reflist_options( self ); /* above */
Vector cur_id_vector;
VectorInit ( &cur_id_vector, 0, 12 );
rc = VNameListCount ( self->sources, &count );
for ( idx = 0; idx < count && rc == 0; ++idx )
{
const char * src_name = NULL;
rc = VNameListGet ( self->sources, idx, &src_name );
if ( rc == 0 && src_name != NULL )
{
const VDatabase *db;
rc = VDBManagerOpenDBRead ( self->vmgr, &db, self->vschema, "%s", src_name );
if ( rc == 0 )
{
const ReferenceList * ref_list;
rc = ReferenceList_MakeDatabase( &ref_list, db, reflist_options, 0, NULL, 0 );
if ( rc == 0 )
{
const ReferenceObj * ref_obj;
rc = ReferenceList_Find( ref_list, &ref_obj, rwd->ref_name, string_size( rwd->ref_name ) );
if ( rc == 0 )
{
INSDC_coord_len len;
rc = ReferenceObj_SeqLength( ref_obj, &len );
if ( rc == 0 )
{
if ( rwd->ref_start == 0 )
rwd->ref_start = 1;
if ( ( rwd->ref_end == 0 )||( rwd->ref_end > len + 1 ) )
rwd->ref_end = ( len - rwd->ref_start ) + 1;
if ( self->primary_alignments )
rc = ref_walker_add_iterator( self, rwd->ref_name, rwd->ref_start, rwd->ref_end, src_name,
&cur_id_vector, db, ref_obj, ref_iter, TBL_PRIM, primary_align_ids );
if ( rc == 0 && self->secondary_alignments )
rc = ref_walker_add_iterator( self, rwd->ref_name, rwd->ref_start, rwd->ref_end, src_name,
&cur_id_vector, db, ref_obj, ref_iter, TBL_SEC, secondary_align_ids );
if ( rc == 0 && self->evidence_alignments )
rc = ref_walker_add_iterator( self, rwd->ref_name, rwd->ref_start, rwd->ref_end, src_name,
&cur_id_vector, db, ref_obj, ref_iter, TBL_EV, evidence_align_ids );
}
ReferenceObj_Release( ref_obj );
}
ReferenceList_Release( ref_list );
}
VDatabaseRelease( db );
}
}
}
if ( rc == 0 )
{
/* walk the reference iterator */
struct ReferenceObj const * ref_obj;
rc = ReferenceIteratorNextReference( ref_iter, NULL, NULL, &ref_obj );
if ( rc == 0 && ref_obj != NULL )
{
if ( self->use_seq_name )
rc = ReferenceObj_Name( ref_obj, &rwd->ref_name );
else
rc = ReferenceObj_SeqId( ref_obj, &rwd->ref_name );
if ( rc == 0 )
{
INSDC_coord_zero first_pos;
INSDC_coord_len len;
rc_t rc_w = ReferenceIteratorNextWindow ( ref_iter, &first_pos, &len );
while ( rc == 0 && rc_w == 0 )
{
rc_t rc_p = ReferenceIteratorNextPos ( ref_iter, !self->no_skip );
if ( rc_p == 0 )
{
rc = ReferenceIteratorPosition ( ref_iter, &rwd->pos, &rwd->depth, &rwd->bin_ref_base );
if ( rwd->depth > 0 && rc == 0 )
{
rc_t rc_sg = 0;
rwd->ascii_ref_base = _4na_to_ascii( rwd->bin_ref_base, false );
if ( self->on_enter_ref_pos != NULL )
rc = self->on_enter_ref_pos( rwd );
while ( rc_sg == 0 && rc == 0 )
{
rc_sg = ReferenceIteratorNextSpotGroup ( ref_iter, &rwd->spot_group, &rwd->spot_group_len );
if ( rc_sg == 0 )
{
rc_t rc_pr = 0;
if ( self->on_enter_spot_group != NULL )
rc = self->on_enter_spot_group( rwd );
while ( rc == 0 && rc_pr == 0 )
{
const PlacementRecord * rec;
rc_pr = ReferenceIteratorNextPlacement ( ref_iter, &rec );
if ( rc_pr == 0 && self->on_alignment != NULL )
rc = ref_walker_walk_alignment( self, ref_iter, rec, rwd );
}
if ( self->on_exit_spot_group != NULL )
rc = self->on_exit_spot_group( rwd );
}
}
if ( self->on_exit_ref_pos != NULL )
rc = self->on_exit_ref_pos( rwd );
}
rc = Quitting();
}
}
}
}
}
/* free cur_id_vector */
ReferenceIteratorRelease ( ref_iter );
}
return rc;
}
static rc_t ref_walker_prepare_1_src( struct ref_walker * self, const char * name )
{
VPath * path = NULL;
const VPath * local_cache = NULL;
const KFile * remote_file = NULL;
rc_t rc = VFSManagerResolveSpec ( self->vfs_mgr, name, &path, &remote_file, &local_cache, true );
if ( rc != 0 )
{
PLOGERR( klogErr, ( klogErr, rc, "cannot resolve '$(n)' via VFSManager", "n=%s", name ) );
}
else
{
char buffer[ 4096 ];
size_t num_read;
rc = VPathReadPath ( path, buffer, sizeof buffer, &num_read );
if ( rc != 0 )
{
PLOGERR( klogErr, ( klogErr, rc, "cannot read path from vpath for '$(n)'", "n=%s", name ) );
}
else
{
if ( rc == 0 )
{
int path_type = ( VDBManagerPathType ( self->vmgr, "%s", buffer ) & ~ kptAlias );
if ( path_type == kptDatabase )
{
const ReferenceList * reflist;
uint32_t options = ( ereferencelist_usePrimaryIds |
ereferencelist_useSecondaryIds |
ereferencelist_useEvidenceIds );
rc = ReferenceList_MakePath( &reflist, self->vmgr, name, options, 0, NULL, 0 );
if ( rc != 0 )
{
PLOGERR( klogErr, ( klogErr, rc, "cannot create ReferenceList for '$(n)'", "n=%s", name ) );
}
else
{
uint32_t count;
rc = ReferenceList_Count( reflist, &count );
if ( rc != 0 )
{
PLOGERR( klogErr, ( klogErr, rc, "ReferenceList_Count() for '$(n)' failed", "n=%s", name ) );
}
else
{
uint32_t idx;
for ( idx = 0; idx < count && rc == 0; ++idx )
{
const ReferenceObj * refobj;
rc = ReferenceList_Get( reflist, &refobj, idx );
if ( rc != 0 )
{
LOGERR( klogInt, rc, "ReferenceList_Get() failed" );
}
else
{
const char * seqid;
rc = ReferenceObj_SeqId( refobj, &seqid );
if ( rc == 0 )
{
INSDC_coord_len seqlen;
rc = ReferenceObj_SeqLength( refobj, &seqlen );
if ( rc == 0 )
{
rc = add_region( &self->regions, seqid, 0, seqlen - 1 );
}
}
ReferenceObj_Release( refobj );
}
}
}
ReferenceList_Release( reflist );
}
}
}
}
KFileRelease( remote_file );
VPathRelease ( local_cache );
VPathRelease ( path );
}
return rc;
}
