static rc_t rr_store_make ( rr_store ** rr )
{
rc_t rc;
if ( rr == NULL )
rc = RC ( rcXF, rcFunction, rcConstructing, rcSelf, rcNull );
else
{
KVector * v;
*rr = NULL;
rc = KVectorMake ( &v );
if ( rc == 0 )
{
rr_store * obj = malloc ( sizeof * obj );
if ( obj == NULL )
{
KVectorRelease ( v );
rc = RC ( rcXF, rcFunction, rcConstructing, rcMemory, rcExhausted );
}
else
{
obj -> v = v;
*rr = obj;
}
}
}
return rc;
}
void free_rna_splice_dict( struct rna_splice_dict * dict )
{
if ( dict != NULL )
{
KVectorRelease ( dict->v );
free( dict );
}
}
static void rr_store_release ( rr_store * rr )
{
if ( rr != NULL )
{
KVectorVisitPtr( rr->v, false, rr_entry_release, NULL );
KVectorRelease ( rr->v );
free( ( void * ) rr );
}
}
static void release_sorter( struct sorter * sorter )
{
if ( sorter != NULL )
{
release_SBuffer( &sorter->buf );
if ( sorter->params.src != NULL )
destroy_raw_read_iter( sorter->params.src );
if ( sorter->store != NULL )
KVectorRelease( sorter->store );
}
}
LIB_EXPORT rc_t CC TableWriterSeq_Whack(const TableWriterSeq* cself, bool commit, uint64_t* rows)
{
rc_t rc = 0;
if( cself != NULL ) {
TableWriterSeq* self = (TableWriterSeq*)cself;
VTable *vtbl;
TableReader_Whack(cself->tmpkey_reader);
if (commit && (rc = TableWriter_GetVTable(cself->base, &vtbl)) == 0 ) {
KMetadata* meta;
if ((rc = VTableOpenMetadataUpdate(vtbl, &meta)) == 0) {
KMDataNode* node = NULL;
if (cself->stats) {
if ((rc = KMetadataOpenNodeUpdate(meta, &node, "MATE_STATISTICS")) == 0) {
rc = TableWriterSeq_WriteStatistics(cself, node);
KMDataNodeRelease(node);
}
}
if ((rc = KMetadataOpenNodeUpdate(meta, &node, "unaligned")) == 0) {
KMDataNode *sub = NULL;
KMDataNodeOpenNodeUpdate(node, &sub, "first-unaligned");
KMDataNodeWriteB64(sub, &self->firstUnaligned);
KMDataNodeRelease(sub);
KMDataNodeOpenNodeUpdate(node, &sub, "first-half-aligned");
KMDataNodeWriteB64(sub, &self->firstHalfAligned);
KMDataNodeRelease(sub);
KMDataNodeRelease(node);
}
KMetadataRelease(meta);
}
}
rc = TableWriter_Whack(cself->base, commit && (rc == 0), rows);
KVectorRelease(cself->stats);
free(self->qual_buf);
free(self);
}
return rc;
}
struct rna_splice_dict * make_rna_splice_dict( void )
{
struct rna_splice_dict * res = NULL;
KVector * v;
rc_t rc = KVectorMake ( &v );
if ( rc == 0 )
{
res = calloc( 1, sizeof * res );
if ( res != NULL )
{
res->v = v;
}
else
{
KVectorRelease ( v );
}
}
return res;
}
static rc_t save_store( struct sorter * sorter )
{
rc_t rc = 0;
if ( sorter->bytes_in_store > 0 )
{
char buffer[ 4096 ];
struct lookup_writer * writer;
if ( sorter->params.mem_limit > 0 )
{
rc = make_subfilename( &sorter->params, sorter->sub_file_id, buffer, sizeof buffer );
if ( rc == 0 )
sorter->sub_file_id++;
}
else
rc = make_dst_filename( &sorter->params, buffer, sizeof buffer );
if ( rc == 0 )
rc = make_lookup_writer( sorter->params.dir, NULL, &writer, sorter->params.buf_size, "%s", buffer );
if ( rc == 0 )
{
rc = KVectorVisitPtr( sorter->store, false, on_store_entry, writer );
release_lookup_writer( writer );
}
if ( rc == 0 )
{
sorter->bytes_in_store = 0;
rc = KVectorRelease( sorter->store );
if ( rc != 0 )
ErrMsg( "KVectorRelease() -> %R", rc );
else
{
sorter->store = NULL;
rc = KVectorMake( &sorter->store );
if ( rc != 0 )
ErrMsg( "KVectorMake() -> %R", rc );
}
}
}
return rc;
}
/******************************************************************************
for the spot-group ( tree-node ), contains a tree of counter's
******************************************************************************/
static void CC whack_spotgroup( BSTNode *n, void *data )
{
spotgrp * sg = ( spotgrp * )n;
#ifdef USE_JUDY
KVectorRelease ( sg->v );
#else
uint32_t idx, count;
count = ( ( sizeof sg->cnv ) / sizeof( sg->cnv[0] ) );
for ( idx = 0; idx < count; ++idx )
{
counter_vector * cv = (counter_vector *)&( sg->cnv[ idx ] );
if ( cv->v != NULL )
{
free( cv->v );
}
}
#endif
if ( sg->name != NULL )
StringWhack ( sg->name );
free( n );
}
