static uint32_t remove_invalid_records( const struct ReferenceObj * const refobj,
DLList * list, INSDC_coord_zero pos )
{
uint32_t res = 0;
spot_group * sg = ( spot_group * )DLListHead( list );
while ( sg != NULL )
{
spot_group *nxt = ( spot_group * )DLNodeNext( ( DLNode * )sg );
PlacementRecord *rec = ( PlacementRecord * )DLListHead( &sg->records );
while ( rec != NULL )
{
PlacementRecord *nxt_rec = ( PlacementRecord * )DLNodeNext( ( DLNode * )rec );
INSDC_coord_zero end_pos = ( rec->pos + rec->len );
bool remove = ( end_pos <= pos );
if ( !remove )
{
AlignmentIterator * al_iter = PlacementRecordCast ( rec, placementRecordExtension0 );
int32_t state = AlignmentIteratorState ( al_iter, NULL );
remove = ( ( state & align_iter_invalid ) == align_iter_invalid );
}
if ( remove )
{
DLListUnlink ( &sg->records, ( DLNode * )rec );
PlacementRecordWhack ( rec );
}
else
{
res++;
}
rec = nxt_rec;
}
sg = nxt;
}
return res;
}
LIB_EXPORT uint32_t CC ReferenceIteratorBasesInserted ( const ReferenceIterator *self,
const INSDC_4na_bin **bases )
{
uint32_t res = align_iter_invalid;
if ( bases != NULL )
{
*bases = NULL;
}
if ( self != NULL )
{
/* PlacementRecordCast returns NULL if self->current_rec is NULL */
AlignmentIterator * al_iter = PlacementRecordCast ( self->current_rec, placementRecordExtension0 );
if ( al_iter != NULL )
res = AlignmentIteratorBasesInserted( al_iter, bases );
}
return res;
}
LIB_EXPORT int32_t CC ReferenceIteratorState ( const ReferenceIterator *self,
INSDC_coord_zero *seq_pos )
{
int32_t res = align_iter_invalid;
if ( seq_pos != NULL )
{
*seq_pos = 0;
}
if ( self != NULL )
{
/* PlacementRecordCast returns NULL if self->current_rec is NULL */
AlignmentIterator * al_iter = PlacementRecordCast ( self->current_rec, placementRecordExtension0 );
if ( al_iter != NULL )
res = AlignmentIteratorState ( al_iter, seq_pos );
}
return res;
}
static rc_t ref_walker_walk_alignment( struct ref_walker * self,
ReferenceIterator * ref_iter,
const PlacementRecord * rec,
ref_walker_data * rwd )
{
walker_rec * xrec = PlacementRecordCast ( rec, placementRecordExtension1 );
rwd->state = ReferenceIteratorState ( ref_iter, &rwd->seq_pos );
rwd->valid = ( ( rwd->state & align_iter_invalid ) == 0 );
rwd->reverse = xrec->reverse;
rwd->first = ( ( rwd->state & align_iter_first ) == align_iter_first );
rwd->last = ( ( rwd->state & align_iter_last ) == align_iter_last );
rwd->skip = ( ( rwd->state & align_iter_skip ) == align_iter_skip );
rwd->match = ( ( rwd->state & align_iter_match ) == align_iter_match );
rwd->bin_alignment_base = ( rwd->state & 0x0F );
rwd->ascii_alignment_base = _4na_to_ascii( rwd->state, rwd->reverse );
if ( !self->omit_quality )
rwd->quality = xrec->quality[ rwd->seq_pos ];
rwd->mapq = rec->mapq;
return self->on_alignment( rwd );
}
static void inc_alignment_iterators( DLList * list, INSDC_coord_zero pos )
{
spot_group * sg = ( spot_group * )DLListHead( list );
while ( sg != NULL )
{
spot_group *nxt = ( spot_group * )DLNodeNext( ( DLNode * )sg );
PlacementRecord *rec = ( PlacementRecord * )DLListHead( &sg->records );
while ( rec != NULL )
{
PlacementRecord *nxt_rec = ( PlacementRecord * )DLNodeNext( ( DLNode * )rec );
AlignmentIterator * al_iter = PlacementRecordCast ( rec, placementRecordExtension0 );
if ( rec->pos <= pos && al_iter != NULL )
{
AlignmentIteratorNext ( al_iter );
}
rec = nxt_rec;
}
sg = nxt;
}
}
LIB_EXPORT uint32_t CC ReferenceIteratorBasesDeleted ( const ReferenceIterator *self,
INSDC_coord_zero *pos, const INSDC_4na_bin **bases )
{
uint32_t res = align_iter_invalid;
if ( bases != NULL )
{
*bases = NULL;
}
if ( self != NULL )
{
/* PlacementRecordCast returns NULL if self->current_rec is NULL */
AlignmentIterator * al_iter = PlacementRecordCast ( self->current_rec, placementRecordExtension0 );
if ( al_iter != NULL )
{
INSDC_coord_zero temp_pos;
res = AlignmentIteratorBasesDeleted( al_iter, &temp_pos );
if ( ( res & align_iter_invalid ) != align_iter_invalid )
{
if ( pos != NULL ) { *pos = temp_pos; }
/* where to get the reference-bases from ? PlacementRecord.ref ! */
if ( res > 0 && bases != NULL )
{
uint8_t * buffer = malloc( res );
if ( buffer != NULL )
{
INSDC_coord_len written;
rc_t rc = ReferenceObj_Read( self->current_rec->ref, temp_pos, res, buffer, &written );
if ( rc == 0 )
{
*bases = buffer;
}
}
}
}
}
}
return res;
}
static rc_t walk_placements( walk_data * data, walk_funcs * funcs )
{
rc_t rc;
do
{
rc = ReferenceIteratorNextPlacement ( data->ref_iter, &data->rec );
if ( GetRCState( rc ) != rcDone )
{
if ( rc != 0 )
{
LOGERR( klogInt, rc, "ReferenceIteratorNextPlacement() failed" );
}
else
{
data->state = ReferenceIteratorState ( data->ref_iter, &data->seq_pos );
data->xrec = ( tool_rec * ) PlacementRecordCast ( data->rec, placementRecordExtension1 );
if ( funcs->on_placement != NULL )
rc = funcs->on_placement( data );
}
}
} while ( rc == 0 );
if ( GetRCState( rc ) == rcDone ) { rc = 0; }
return rc;
}
static void handle_base_pos( ReferenceIterator *ref_iter,
const PlacementRecord *rec,
uint8_t * qual,
bool nodebug )
{
INSDC_coord_zero seq_pos;
int32_t state = ReferenceIteratorState ( ref_iter, &seq_pos );
ext_rec *xrec = ( ext_rec * ) PlacementRecordCast ( rec, placementRecordExtension1 );
bool reverse = xrec->reverse;
if ( !nodebug )
OUTMSG(( "[%lu.%u ", rec->id, seq_pos ));
*qual = xrec->quality[ seq_pos ];
if ( ( state & align_iter_first ) == align_iter_first )
{
char mapq = ( rec->mapq + 33 );
OUTMSG(( "^%c", mapq ));
}
if ( ( state & align_iter_last ) == align_iter_last )
OUTMSG(( "$" ));
if ( ( state & align_iter_insert ) == align_iter_insert )
{
const INSDC_4na_bin *bases;
uint32_t n = ReferenceIteratorBasesInserted ( ref_iter, &bases );
char * s = dup_2_ascii( bases, n, reverse );
OUTMSG(( "+%u%s", n, s ));
free( s );
}
if ( ( state & align_iter_delete ) == align_iter_delete )
{
const INSDC_4na_bin *bases;
INSDC_coord_zero ref_pos;
uint32_t n = ReferenceIteratorBasesDeleted ( ref_iter, &ref_pos, &bases );
if ( bases != NULL )
{
char * s = dup_2_ascii( bases, n, reverse );
OUTMSG(( "-%u%s", n, s ));
free( s );
free( (void *) bases );
}
else
{
OUTMSG(( "-%u?", n ));
}
}
if ( ( state & align_iter_skip ) == align_iter_skip )
OUTMSG(( "*" ));
else
{
if ( ( state & align_iter_match ) == align_iter_match )
OUTMSG(( "%c", reverse ? ',' : '.' ));
else
OUTMSG(( "%c", _4na_to_ascii( state & 0x0F, reverse ) ));
}
if ( !nodebug )
OUTMSG(( "]" ));
}
