Exemple #1
0
static rc_t SpotGroupSplitterFactory_Init( const SRASplitterFactory* cself )
{
    rc_t rc = 0;
    SpotGroupSplitterFactory* self = ( SpotGroupSplitterFactory* )cself;

    if ( self == NULL )
    {
        rc = RC( rcSRA, rcType, rcConstructing, rcParam, rcNull );
    }
    else
    {
        rc = SRATableOpenColumnRead( self->table, &self->col, "SPOT_GROUP", vdb_ascii_t );
        if ( rc != 0 )
        {
            if ( GetRCState( rc ) == rcNotFound )
            {
                LOGMSG(klogWarn, "Column SPOT_GROUP was not found, param ignored");
                rc = 0;
            }
            else if ( GetRCState( rc ) == rcExists )
            {
                rc = 0;
            }
        }
    }
    return rc;
}
Exemple #2
0
static rc_t walk_ref_iter_reference( ReferenceIterator *ref_iter,
                                     struct ReferenceObj const * refobj,
                                     bool skip_empty,
                                     bool nodebug )
{
    rc_t rc = 0;
    while ( rc == 0 )
    {
        INSDC_coord_zero first_pos;
        INSDC_coord_len len;
        rc = ReferenceIteratorNextWindow ( ref_iter, &first_pos, &len );
        if ( rc != 0 )
        {
            if ( GetRCState( rc ) != rcDone )
                LOGERR( klogInt, rc, "ReferenceIteratorNextWindow() failed" );
        }
        else
        {
            OUTMSG(( "walking ref-iter on window: ( from %u to %u )\n",
                     first_pos, first_pos + len - 1 ));
            rc = walk_ref_iter_window( ref_iter, refobj, skip_empty, nodebug );
        }
    }
    if ( GetRCState( rc ) == rcDone ) rc = 0;
    return rc;
}
Exemple #3
0
static rc_t ReadFilterSplitterFactory_Init( const SRASplitterFactory* cself )
{
    rc_t rc = 0;
    ReadFilterSplitterFactory* self = ( ReadFilterSplitterFactory* )cself;

    if ( self == NULL )
    {
        rc = RC( rcSRA, rcType, rcConstructing, rcParam, rcNull );
    }
    else
    {
        rc = SRATableOpenColumnRead( self->table, &self->col_rdf, "READ_FILTER", sra_read_filter_t );
        if ( rc != 0 )
        {
            if ( GetRCState( rc ) == rcNotFound )
            {
                LOGMSG( klogWarn, "Column READ_FILTER was not found, param ignored" );
                rc = 0;
            }
            else if ( GetRCState( rc ) == rcExists )
            {
                rc = 0;
            }
        }
    }
    return rc;
}
static
rc_t RefNameMake ( RefName **objp, const VTable *tbl, const VCursor *native_curs )
{
    rc_t rc;

    /* create the object */
    RefName *obj = malloc ( sizeof * obj );
    if ( obj == NULL ) {
        rc = RC ( rcXF, rcFunction, rcConstructing, rcMemory, rcExhausted );
    } else {
	obj->curs=NULL;
        /* open the reference cursor */
	rc = AlignRefTableCursor(tbl, native_curs, &obj->curs, NULL);
	if(rc == 0){
                /* add columns to cursor */
		rc = VCursorAddColumn(obj->curs, &obj->name_idx, "(utf8)REF_NAME");
		if( GetRCObject(rc) == rcColumn && GetRCState(rc) == rcNotFound ) {
			rc = VCursorAddColumn(obj->curs, &obj->name_idx, "(utf8)NAME");
		}
		if(GetRCState(rc) == rcExists){
			rc = 0;
		}
                if( rc == 0 ) {
                    *objp = obj;
                    return 0;
                }
                VCursorRelease ( obj -> curs );
        }
        free ( obj );
    }
    return rc;
}
Exemple #5
0
static char *translate_accession( SRAPath *my_sra_path,
                           const char *accession,
                           const size_t bufsize )
{
    rc_t rc;
    char * res = calloc( 1, bufsize );
    if ( res == NULL ) return NULL;

    rc = SRAPathFind( my_sra_path, accession, res, bufsize );
    if ( GetRCState( rc ) == rcNotFound )
    {
        free( res );
        return NULL;
    }
    else if ( GetRCState( rc ) == rcInsufficient )
    {
        free( res );
        return translate_accession( my_sra_path, accession, bufsize * 2 );
    }
    else if ( rc != 0 )
    {
        free( res );
        return NULL;
    }
    return res;
}
Exemple #6
0
rc_t KCipherMakeInt (KCipher ** new_cipher, kcipher_type type)
{
    rc_t rc;

    *new_cipher = NULL;

#if 0
    rc = KCipherVecAesNiMake (new_cipher, type);
    if (rc)
    {
        if (GetRCState(rc) == rcUnsupported)
        {
#if USE_SLOW_ONES
            rc = KCipherVecRegMake (new_cipher, type);
            if (rc)
            {
                if (GetRCState(rc) == rcUnsupported)
                {
                    rc = KCipherVecMake (new_cipher, type);
                    if (GetRCState(rc) == rcUnsupported)
                    {
#endif
#endif
                        rc = KCipherByteMake (new_cipher, type);
#if 0
#if USE_SLOW_ONES
                    }
                }
            }
#endif
        }
    }
#endif
    return rc;
}
Exemple #7
0
static rc_t walk_spot_group( walk_data * data, walk_funcs * funcs )
{
    rc_t rc;
    do
    {
        rc = ReferenceIteratorNextSpotGroup ( data->ref_iter, &data->spotgroup, &data->spotgroup_len );
        if ( GetRCState( rc ) != rcDone )
        {
            if ( rc != 0 )
            {
                LOGERR( klogInt, rc, "ReferenceIteratorNextPos() failed" );
            }
            else
            {
                if ( funcs->on_enter_spotgroup != NULL )
                    rc = funcs->on_enter_spotgroup( data );
                if ( rc == 0 )
                    rc = walk_placements( data, funcs );
                if ( rc == 0 && funcs->on_exit_spotgroup != NULL )
                    rc = funcs->on_exit_spotgroup( data );
            }
        }
    } while ( rc == 0 );
    if ( GetRCState( rc ) == rcDone ) { rc = 0; }
    return rc;
}
Exemple #8
0
static rc_t walk_ref_window( walk_data * data, walk_funcs * funcs )
{
    rc_t rc;
    do
    {
        rc = ReferenceIteratorNextWindow ( data->ref_iter, &data->ref_window_start, &data->ref_window_len );
        if ( GetRCState( rc ) != rcDone )
        {
            if ( rc != 0 )
            {
                LOGERR( klogInt, rc, "ReferenceIteratorNextWindow() failed" );
            }
            else
            {
                if ( funcs->on_enter_ref_window != NULL )
                    rc = funcs->on_enter_ref_window( data );
                if ( rc == 0 )
                    rc = walk_ref_pos( data, funcs );
                if ( rc == 0 && funcs->on_exit_ref_window != NULL )
                    rc = funcs->on_exit_ref_window( data );
            }
        }
    } while ( rc == 0 );
    if ( GetRCState( rc ) == rcDone ) { rc = 0; }
    return rc;
}
Exemple #9
0
static
rc_t SRAReader_ColumnsOpen(SRAReader *self)
{
    rc_t rc = 0;
    int i = 0;

    while(self->cols[i].name != NULL) {
        if( self->cols[i].opt == SRAREADER_COL_MANDATORY || (self->options & self->cols[i].opt) ) {
            rc = SRATableOpenColumnRead(self->table, &self->cols[i].col, self->cols[i].name, self->cols[i].datatype);
            if( rc != 0 ) {
                if( ((self->cols[i].opt & SRAREADER_COL_OPTIONAL) && GetRCState(rc) == rcNotFound) ) {
                    PLOGERR(klogInfo, (klogWarn, rc, "column $(c)", PLOG_S(c), self->cols[i].name));
                    rc = 0;
                } else if( GetRCState(rc) == rcExists ) {
                    rc = 0;
                } else {
                    PLOGERR(klogInfo, (klogErr, rc, "column $(c)", PLOG_S(c), self->cols[i].name));
                    break;
                }
            }
        }
        i++;
    }
    return rc;
}
Exemple #10
0
static
rc_t populate_rdfilt_tbl ( BSTree *rftype_tbl, const VSchema *schema )
{
    rc_t rc;
    uint32_t i;
    const char *rftypes [] =
    {
        "NCBI:SRA:read_filter",
        "INSDC:SRA:read_filter"
    };

    BSTreeInit ( rftype_tbl );

    for ( rc = 0, i = 0; i < sizeof rftypes / sizeof rftypes [ 0 ]; ++ i )
    {
        VTypedecl td;
        const char *decl = rftypes [ i ];
        rc = VSchemaResolveTypedecl ( schema, & td, decl );
        if ( rc == 0 )
        {
            BSTNode *exist;

            stype_id *n = malloc ( sizeof * n );
            if ( n == NULL )
            {
                rc = RC ( rcExe, rcNode, rcAllocating, rcMemory, rcExhausted );
                LOGERR ( klogInt, rc, "failed to record read_filter data type" );
                break;
            }

            n -> redact_value = NULL;
            n -> type_id = td . type_id;
            n -> elem_size = 8;

            rc = BSTreeInsertUnique ( rftype_tbl, & n -> n, & exist, stype_id_sort );
            if ( rc != 0 )
            {
                free ( n );
                if ( GetRCState ( rc ) != rcExists )
                {
                    LOGERR ( klogInt, rc, "failed to record read_filter data type" );
                    break;
                }
                rc = 0;
            }
        }
        else if ( GetRCState ( rc ) == rcNotFound )
        {
            rc = 0;
        }
        else
        {
            break;
        }
    }

    return rc;
}
Exemple #11
0
static rc_t SDataPrepareCols(struct SData* self,
    const char* rdFilterName, const char* readFilterName)
{
    rc_t rc = 0;

    assert(self);

    if (rc == 0) {
        const char name[] = "NREADS";
        rc = SRATableOpenColumnRead(self->_rdTbl,
            &self->_NReadsCol, name, vdb_uint8_t);
        if (rc != 0) {
            if (GetRCState(rc) == rcNotFound) {
                rc = 0;
            }
            else {
                plogerr(klogErr, rc,
                    "while calling SRATableOpenColumnRead($name)", "name=%s",
                    name);
            }
        }
    }

    /* It the physical column exists, open it */
    if (rc == 0) {
        rc = SRATableOpenColumnRead(self->_rdTbl,
            &self->_origFilterCol, rdFilterName, sra_read_filter_t);
        if (rc == 0) {
            plogmsg(klogDebug1,
                "Found '$(name)' column", "name=%s", rdFilterName);
            self->_existedRD_FILTER = true;
            self->_origFilterColName = rdFilterName;
        }
        else if (GetRCState(rc) == rcNotFound) {
            plogmsg(klogDebug1,
                "Column '$(name)' does not exist", "name=%s", rdFilterName);
            rc = 0;
        }
        else {
            plogerr(klogErr, rc, "while calling SRATableOpenColumnRead($name)",
                "name=%s", rdFilterName);
        }
    }

    /* Otherwise open the virtual one */
    if (rc == 0 && ! self->_existedRD_FILTER) {
        rc = SRATableOpenColumnRead(self->_rdTbl,
            &self->_origFilterCol, readFilterName, sra_read_filter_t);
        if (rc != 0) {
            plogerr(klogErr, rc,
                "while calling SRATableOpenColumnRead($name)", "name=%s",
                readFilterName);
        }
    }

    return rc;
}
Exemple #12
0
static
rc_t SFFLoaderFmtWriteDataFile(SFFLoaderFmt* self, const SRALoaderFile* file)
{
    rc_t rc = 0;

    while( rc == 0 ) {
        if( self->curr_read_number == 0 ) {
            if( (rc = SFFLoaderFmtReadCommonHeader(self, file)) == 0 ) {
                DEBUG_MSG (5, ("%s: Common header ok: %u reads\n", self->file_name, self->header.number_of_reads));
                DEBUG_MSG (8, ("%s: flow_chars: [%hu] %s\n", self->file_name, self->header.num_flows_per_read, self->flow_chars.data));
                DEBUG_MSG (8, ("%s: key_seq: [%hu] %s\n", self->file_name, self->header.key_length, self->key_seq.data));
            } else if( GetRCObject(rc) == (enum RCObject)rcData && GetRCState(rc) == rcIgnored ) {
                rc = 0;
                break;
            }
        }
        if( rc == 0 && self->header.number_of_reads != 0 && 
            (rc = SFFLoaderFmtSkipIndex(self, file)) == 0 &&
            (rc = SFFLoaderFmtReadDataHeader(self, file)) == 0 &&
            (rc = SFFLoaderFmtReadData(self, file)) == 0 ) {
            if( self->w454 ) {
                rc = SRAWriter454_WriteRead(self->w454, file, &self->name, &self->read, &self->quality,
                                         self->skip_signal ? NULL : &self->signal,
                                         self->skip_signal ? NULL : &self->position,
                                         self->read_header.clip_quality_left, self->read_header.clip_quality_right,
                                         self->read_header.clip_adapter_left, self->read_header.clip_adapter_right);
            } else {
                rc = SRAWriterIonTorrent_WriteRead(self->wIonTorrent, file, &self->name, &self->read, &self->quality,
                         self->skip_signal ? NULL : &self->signal,
                         self->skip_signal ? NULL : &self->position,
                         self->read_header.clip_quality_left, self->read_header.clip_quality_right,
                         self->read_header.clip_adapter_left, self->read_header.clip_adapter_right);
            }
            if( rc == 0 ) {
                ++self->curr_read_number;
            }
        }
        if( rc != 0 && (GetRCObject(rc) != rcTransfer && GetRCState(rc) != rcDone) ) {
            SRALoaderFile_LOG(file, klogErr, rc, "on or about read #$(i)", PLOG_U32(i), self->curr_read_number + 1);
        } else if( self->curr_read_number == self->header.number_of_reads ) {
            DEBUG_MSG(5, ("%s: done loading declared %u reads\n", self->file_name, self->curr_read_number));
            self->curr_read_number = 0;
            /* will skip indexes if they are at eof */
            if( (rc = SFFLoaderFmtSkipIndex(self, file)) == 0 ) {
                /* This should be the end of file and/or beginning of next */
                if( (rc = SFFLoaderFmt_ReadBlock(self, file, 0, "EOF", false)) == 0 ) {
                    if( self->file_buf == NULL ) {
                        DEBUG_MSG(5, ("%s: EOF detected\n", self->file_name));
                        self->index_correction = 0;
                        break;
                    }
                }
            }
        }
    }
    return rc;
}
Exemple #13
0
static rc_t CC NodeDataReadAttribs(NodeData* data, const KXMLNode* node,
    const char* parentName, uint32_t idx)
{
    rc_t rc = 0;

    assert(node && parentName && data);

    if (DEBUG_PRINT) OUTMSG(("<%s ", data->nodeName));

    GET_ATTR(node, id);
    GET_ATTR(node, path);
    GET_ATTR(node, name);
    GET_ATTR(node, mtime);
    GET_ATTR(node, filetype);
    GET_ATTR(node, md5);
    GET_ATTR(node, crc32);

    READ_ATTR(node, size);
    READ_ATTR(node, offset);

    if (rc == 0)
    {
/* TODO: what size is negative no error is detected */
        char * attr = "size";
        rc = KXMLNodeReadAttrAsU64(node, attr, &data->iSize);
        if (rc != 0) {
            if (GetRCState(rc) == rcNotFound) {
                rc = 0;
            }
        }

        attr = "offset";
        rc = KXMLNodeReadAttrAsU64(node, attr, &data->iOffset);
        if (rc != 0) {
            if (GetRCState(rc) == rcNotFound) {
                rc = 0;
            }
        }
/*          else if (data->nodeName) {
                PLOGERR(klogErr, (klogErr, rc,
                    "while calling KXMLNodeReadAttrAsU64($(name)/@$(attr))",
                    "name=%s,attr=%s", data->nodeName, attr));
            }*/
        if (DEBUG_PRINT) 
        {
            OUTMSG(("%s=\"%lu\" ", attr, data->iSize));
            OUTMSG(("%s=\"%lu\" ", attr, data->iOffset));
        }
    }

    if (DEBUG_PRINT) OUTMSG((">"));
    if (DEBUG_PRINT && data->nodeValue) OUTMSG(("%s", data->nodeValue));
    if (DEBUG_PRINT) OUTMSG(("</%s>\n", data->nodeName));

    return rc;
}
Exemple #14
0
LIB_EXPORT rc_t CC AlignAccessAlignmentEnumeratorNext(const AlignAccessAlignmentEnumerator *cself) {
    rc_t rc;
    AlignAccessAlignmentEnumerator *self = (AlignAccessAlignmentEnumerator *)cself;
    int32_t refSeqID;

AGAIN:
    if (self->innerSelf != NULL) {
        BAMAlignmentRelease(self->innerSelf);
        self->innerSelf = NULL;
    }
    if (self->atend != 0)
        return AlignAccessAlignmentEnumeratorEOFCode;
    
    if (self->slice == NULL) {
        rc = BAMFileRead2(self->parent->innerSelf, &self->innerSelf);
        if (rc) {
            if (GetRCState(rc) == rcNotFound && GetRCObject(rc) == rcRow) {
                self->atend = 1;
                rc = AlignAccessAlignmentEnumeratorEOFCode;
            }
        }
        return rc;
    }
    rc = BAMFileReadSlice(self->parent->innerSelf, &self->innerSelf, self->slice);
    if (rc) {
        if (GetRCState(rc) == rcNotFound && GetRCObject(rc) == rcRow) {
            self->atend = 1;
            rc = AlignAccessAlignmentEnumeratorEOFCode;
        }
        return rc;
    }
    if (!BAMAlignmentIsMapped(self->innerSelf))
        goto AGAIN;

    BAMAlignmentGetRefSeqId(self->innerSelf, &refSeqID);
    if (self->refSeqID != refSeqID) {
        self->atend = 1;
        rc = AlignAccessAlignmentEnumeratorEOFCode;
    }
    else if (self->endpos != 0) {
        int64_t pos;
        uint32_t length;

        BAMAlignmentGetPosition2(self->innerSelf, &pos, &length);
        if (pos >= (int64_t)self->endpos) {
            self->atend = 1;
            rc = AlignAccessAlignmentEnumeratorEOFCode;
        }
        else {
            int64_t const endpos = pos + length;
            if (endpos <= self->startpos)
                goto AGAIN;
        }
    }
    return rc;
}
Exemple #15
0
static rc_t walk_ref_iter_position( ReferenceIterator *ref_iter,
                                    struct ReferenceObj const * refobj,
                                    bool skip_empty,
                                    bool nodebug )
{
    INSDC_coord_zero pos;
    uint32_t depth;
    INSDC_4na_bin base;

    rc_t rc = ReferenceIteratorPosition ( ref_iter, &pos, &depth, &base );
    if ( rc != 0 )
    {
        if ( GetRCState( rc ) != rcDone )
            LOGERR( klogInt, rc, "ReferenceIteratorNextPos() failed" );
    }
    else
    {
        rc_t rc1 = 0;
        const char * reference_name = NULL;
        char c = _4na_to_ascii( base, false );
        rc = ReferenceObj_SeqId( refobj, &reference_name );
        if ( rc == 0 )
        {
            OUTMSG(( "%s\t%u\t%c\t%u", reference_name, pos, c, depth ));
            if ( depth > 0 )
            {
                const PlacementRecord *rec;
                rc1 = ReferenceIteratorNextPlacement ( ref_iter, &rec );
                if ( rc1 == 0 )
                {
                    uint8_t qualities[ 4096 ];
                    uint32_t i = 0;
                    OUTMSG(( "\t" ));
                    while ( rc1 == 0 )
                    {
                        handle_base_pos( ref_iter, rec, &( qualities[ i++ ] ), nodebug );
                        rc1 = ReferenceIteratorNextPlacement ( ref_iter, &rec );
                    }
                    OUTMSG(( "\t" ));
                    for ( i = 0; i < depth; ++i )
                    {
                        char c = ( qualities[ i ] + 33 );
                        OUTMSG(( "%c", c ));
                    }
                }
            }
            OUTMSG(( "\n" ));
        }
        if ( GetRCState( rc1 ) == rcDone ) rc1 = 0;
        rc = rc1;
    } 
    return rc;
}
Exemple #16
0
static rc_t bam_header(const VDatabase* db) {
    rc_t rc = 0;
    const char path[] = "BAM_HEADER";
    const KMetadata* meta = NULL;
    const KMDataNode* node = NULL;
    char* buffer = NULL;
    assert(db);
    if (rc == 0) {
        rc = VDatabaseOpenMetadataRead(db, &meta);
        DISP_RC(rc, "while calling VDatabaseOpenMetadataRead");
    }
    if (rc == 0) {
        rc = KMetadataOpenNodeRead(meta, &node, "%s", path);
        if (GetRCState(rc) == rcNotFound)
        {   rc = 0; }
        else {
            DISP_RC2(rc, path, "while calling KMetadataOpenNodeRead");
            if (rc == 0) {
                int i = 0;
                size_t bsize = 0;
                size_t size = 1024;
                for (i = 0; i < 2; ++i) {
                    free(buffer);
                    bsize = size + 1;
                    buffer = malloc(bsize);
                    if (buffer == NULL) {
                        rc = RC(rcExe, rcStorage, rcAllocating,
                            rcMemory, rcExhausted);
                    }
                    else {
                        rc = KMDataNodeReadCString(node, buffer, bsize, &size);
                        if (rc == 0) {
                            break;
                        }
                        else if (i == 0
                            && GetRCObject(rc) == (enum RCObject)rcBuffer
                            && GetRCState (rc) ==          rcInsufficient)
                        {
                            rc = 0;
                        }
                    }
                    DISP_RC2(rc, path, "while calling KMDataNodeReadCString");
                }
            }
        }
    }
    if (rc == 0 && buffer)
    {   OUTMSG(("BAM_HEADER: {\n%s}\n\n", buffer)); }
    DESTRUCT(KMDataNode, node);
    DESTRUCT(KMetadata, meta);
    free(buffer);
    return rc;
}
Exemple #17
0
/* GetSpotId
 *  convert spot name to spot id
 *
 *  "id" [ OUT ] - return parameter for min(spot_id)-max(spot_id)
 *
 *  "spot_name" [ IN ] - external spot name string
 *  in platform canonical format.
 */
LIB_EXPORT rc_t CC SRATableGetSpotId ( const SRATable *self,
        spotid_t *rslt, const char *spot_name )
{
    rc_t rc;
    if( self == NULL || spot_name == NULL){
        rc=RC(rcSRA, rcTable, rcListing, rcSelf, rcName);
    } else {
        rc=VCursorParamsSet((struct VCursorParams*)self->curs,"QUERY_BY_NAME" ,spot_name);
        if( rc == 0) {
            struct {
                uint64_t start_id;
                uint64_t id_count;
                int64_t x;
                int64_t y;
            } out;
            uint32_t idx,len;
            rc = VCursorAddColumn(self->curs, &idx, "SPOT_IDS_FOUND");
            if( rc == 0 || GetRCState(rc) == rcExists){
                rc = VCursorReadDirect(self->curs,1,idx,sizeof(out) * 8,&out, 1 , &len);
                if ( rc == 0 ) {
                    if(out.id_count==1) {
                        if(rslt) *rslt=out.start_id;
                        return 0;
                    } else if(out.id_count > 1) { /*** doing table range scan in Name space - not relying on X and Y***/
                        uint32_t x_idx;
                        rc = VCursorAddColumn(self->curs, &x_idx, "X");
                        if( rc == 0 || GetRCState(rc) == rcExists){
                            uint32_t y_idx;
                            rc = VCursorAddColumn(self->curs, &y_idx, "Y");
                            if(rc == 0 || GetRCState(rc) == rcExists){
                                spotid_t rowid;
                                for(rowid = out.start_id; rowid < out.start_id + out.id_count; rowid ++){
                                    int32_t x,y;
                                    rc = VCursorReadDirect(self->curs,rowid,x_idx,32,&x,1, &len);
                                    if(rc == 0){
                                        rc = VCursorReadDirect(self->curs,rowid,y_idx,32,&y,1, &len);
                                        if(rc == 0 && x==out.x && y==out.y){
                                            if(rslt) *rslt=rowid;
                                            return 0;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    rc = RC ( rcSRA, rcIndex, rcSearching, rcColumn, rcNotFound );
                }
            }
        }
    }
    return rc;
}
Exemple #18
0
static
rc_t RefPosMake ( RefPos **objp, const VTable *tbl, const VCursor *native_curs )
{
    rc_t rc;

    /* create the object */
    RefPos *obj = malloc ( sizeof * obj );
    if ( obj == NULL ) {
        rc = RC ( rcXF, rcFunction, rcConstructing, rcMemory, rcExhausted );
    } else {
	obj->curs=NULL;
        BSTreeInit(&obj->tr_range);
        /* open the reference table cursor*/
	  
	if( (rc = AlignRefTableCursor(tbl, native_curs, &obj->curs, NULL)) == 0 ) {
                uint32_t itmp;
                if(  (rc = VCursorAddColumn(obj->curs, &itmp, "(U32)MAX_SEQ_LEN")) == 0 || GetRCState(rc) == rcExists)  {
                    const void *base;
                    uint32_t row_len;
                    rc = VCursorCellDataDirect(obj->curs, 1, itmp, NULL, &base, NULL, &row_len);
                    if(rc == 0) {
                        assert(row_len == 1);
                        memcpy(&obj->max_seq_len, base, 4);
                    }
                }
                if( GetRCObject(rc) == rcColumn && GetRCState(rc) == rcNotFound ) {
		    /*** no MAX_SEQ_LEN means that REF_POS==REF_START **/
		    VCursorRelease(obj->curs);
		    obj->curs = NULL;
                    obj->max_seq_len = 0;
		    obj->name_range_idx = 0;
		    obj->name_idx = 0;
                    rc = 0;
                } else if( rc == 0 ) {
                        /* add columns to cursor */
			rc = VCursorAddColumn(obj->curs, &obj->name_idx, "(utf8)NAME");
			if(rc == 0 || GetRCState(rc) == rcExists)
				rc = VCursorAddColumn(obj->curs, &obj->name_range_idx, "NAME_RANGE");
			if(GetRCState(rc) == rcExists)
				rc = 0;
                }
        }
        if( rc == 0 ) {
            *objp = obj;
        } else {
	    VCursorRelease(obj->curs);
            free(obj);
        }
    }
    return rc;
}
Exemple #19
0
static
rc_t LocalRefIDMake ( LocalRefID **objp, const VTable *tbl, const VCursor *native_curs)
{
    rc_t rc;
    /* create the object */
    LocalRefID *obj = malloc ( sizeof * obj );
    if ( obj == NULL )
    {
        rc = RC( rcXF, rcFunction, rcConstructing, rcMemory, rcExhausted );
    }
    else
    {
        const VCursor *curs=NULL;
        /* open the reference table cursor*/
        rc = AlignRefTableCursor( tbl, native_curs, &curs, NULL );
        if ( rc == 0 )
        {
            uint32_t itmp;
            rc = VCursorAddColumn( curs, &itmp, "(U32)MAX_SEQ_LEN" );
            if ( rc == 0 || GetRCState( rc ) == rcExists )
            {
                const void *base;
                uint32_t row_len;
                rc = VCursorCellDataDirect( curs, 1, itmp, NULL, &base, NULL, &row_len );
                if ( rc == 0 )
                {
                    assert( row_len == 1 );
                    memmove( &obj->max_seq_len, base, 4 );
                }
            }

            if ( ( GetRCObject( rc ) == ( enum RCObject )rcColumn ) && ( GetRCState( rc ) == rcNotFound ) )
            {
                obj->max_seq_len = 0;
                rc = 0;
            }

            VCursorRelease( curs );
            if ( rc == 0 )
            {
                *objp = obj;
                return 0;
            }
        }
        free ( obj );
    }
    return rc;
}
Exemple #20
0
CVDBTable::CVDBTable(const CVDB& db,
                     const char* table_name,
                     EMissing missing)
    : m_Db(db),
      m_Name(table_name)
{
    DECLARE_SDK_GUARD();
    if ( rc_t rc = VDatabaseOpenTableRead(db, x_InitPtr(), table_name) ) {
        *x_InitPtr() = 0;
        RCState rc_state = GetRCState(rc);
        int rc_object = GetRCObject(rc);
        if ( rc_state == rcNotFound &&
             (rc_object == rcParam ||
              rc_object == rcPath) ) {
            // missing table in the DB
            if ( missing != eMissing_Throw ) {
                return;
            }
            NCBI_THROW2_FMT(CSraException, eNotFoundTable,
                            "Cannot open VDB table: "<<*this, rc);
        }
        else {
            // other errors
            NCBI_THROW2_FMT(CSraException, eOtherError,
                            "Cannot open VDB table: "<<*this, rc);
        }
    }
}
Exemple #21
0
static rc_t resolve_accession( VFSManager * vfs_mgr, const char * accession, const String ** path )
{
    VResolver * resolver;
    rc_t rc = VFSManagerGetResolver( vfs_mgr, &resolver );
    if ( rc == 0 )
    {
        const VPath * vpath;
        rc = VPathMakeSysPath( ( VPath** )&vpath, accession );
        if ( rc == 0 )
        {
            const VPath * rpath;
            rc = VResolverLocal( resolver, vpath, &rpath );
            if ( GetRCState( rc ) == rcNotFound )
                rc = VResolverRemote( resolver, vpath, &rpath, NULL );
            if ( rc == 0 )
            {
                const String * s;
                rc = VPathMakeString( rpath, &s );
                if ( rc == 0 )
                {
                    rc = StringCopy ( path, s );
                    free ((void*)s);
                }
                VPathRelease ( rpath );
            }
            VPathRelease ( vpath );
        }
        VResolverRelease( resolver );
    }
    return rc;
}
Exemple #22
0
static void CC nxt_avail_pos_cb( DLNode * n, void * data )
{
    pi_ref_nxt_avail_pos_ctx * ctx = ( pi_ref_nxt_avail_pos_ctx * ) data;
    if ( ctx->rc == 0 )
    {
        pi_entry * pie = ( pi_entry * )n;
        rc_t rc = PlacementIteratorNextAvailPos ( pie->pi, &(pie->nxt_avail.first), &(pie->nxt_avail.len) );
        if ( rc == 0 )
        {
/*            OUTMSG(( "nxt_avail.first=%u w.last=%u\n", pie->nxt_avail.first, pie->w.last )); */
            ( ctx->count )++;
            if ( ctx->min_pos_initialized )
            {
                if ( pie->nxt_avail.first < ctx->min_pos )
                {
                    ctx->min_pos = pie->nxt_avail.first;
                    ctx->min_len = pie->nxt_avail.len;
                }
            }
            else
            {
                ctx->min_pos = pie->nxt_avail.first;
                ctx->min_len = pie->nxt_avail.len;
                ctx->min_pos_initialized = true;
            }
        }
        else
        {
            if ( GetRCState( rc ) != rcDone )
                ctx->rc = rc;
        }
    }
}
Exemple #23
0
rc_t IlluminaSpot_Add(IlluminaSpot* spot, const pstring* name, const pstring* barcode, const IlluminaRead* read)
{
    rc_t rc = 0;

    if( spot->nreads == 0 ) {
        rc = IlluminaSpot_Set(spot, spot->nreads++, name, barcode, read);
    } else if( pstring_cmp(spot->name, name) == 0 ) {
        /* look if same read_id was already seen in this spot */
        int32_t k;
        for(k = 0; k < spot->nreads; k++) {
            if( spot->reads[k].read_id == read->read_id ) {
                const char* field;
                rc = IlluminaSpot_Append(spot, k, barcode, read, &field);
                if( GetRCState(rc) == rcDuplicate && read->read_id == ILLUMINAWRITER_READID_NONE ) {
                    /* may be it is the case when readids are missing on defline and these are separate reads */
                    k = spot->nreads + 1;
                    rc = 0;
                } else if( rc != 0 ) {
                    PLOGERR(klogErr, (klogErr, rc, "$(field) for spot '$(s)'", PLOG_2(PLOG_S(field),PLOG_S(s)), field, spot->name->data));
                }
                break;
            }
        }
        if( rc == 0 && k >= spot->nreads ) {
            /* read was not found, adddind new read to this spot */
            rc = IlluminaSpot_Set(spot, spot->nreads++, name, barcode, read);
        }
    } else {
        rc = RC(rcSRA, rcFormatter, rcReading, rcData, rcIgnored);
    }
    return rc;
}
Exemple #24
0
/* FindInRepo
 *  find accession in a repository
 */
static
rc_t SRAPathFindInRepo ( const NCBISRAPath *self, NCBIRepository *repo, const char *accession, 
                         char *path, size_t path_max, size_t *rep_len, int vol_type )
{
    SRAPathString *srv;

    PATH_DEBUG (("SRAPathFindInRepo(%s)\n", AlgToStr(repo->type)));

    /* look for accession on a rep-server */
    for ( srv = ( SRAPathString* ) DLListHead ( & repo -> repsrv ); srv != NULL; srv = ( SRAPathString* ) DLNodeNext ( & srv -> n ) )
    {
        /* try with this server */
        rc_t rc = SRAPathFindOnServer ( self, repo, srv, accession, path, path_max, vol_type );
        if ( rc == 0 )
        {
            /* make sure server is at head of list */
            if ( DLNodePrev ( & srv -> n ) != NULL )
            {
                DLListUnlink ( & repo -> repsrv, & srv -> n );
                DLListPushHead ( & repo -> repsrv, & srv -> n );
            }

            if ( rep_len != NULL )
                * rep_len = strlen ( srv -> path );
            
            return 0;
        }

        if ( GetRCState ( rc ) != rcNotFound )
            return rc;
    }

    return RC ( rcSRA, rcMgr, rcSelecting, rcPath, rcNotFound );
}
Exemple #25
0
/* Make
 */
static
rc_t SRAMgrInitPath ( SRAMgr *mgr, const KDirectory *wd )
{
#if OLD_SRAPATH_MGR
    /* try to make the path manager */
    rc_t rc = SRAPathMake ( & mgr -> _pmgr, wd );

    if ( GetRCState ( rc ) == rcNotFound && GetRCTarget ( rc ) == rcDylib )
    {
        /* we are operating outside of the archive */
        assert ( mgr -> _pmgr == NULL );
        rc = 0;
    }

    return rc;
#else
    KConfig *kfg;
    rc_t rc = KConfigMake ( & kfg, NULL );
    if ( rc == 0 )
    {
        VFSManager *vfs;
        rc = VFSManagerMake ( & vfs );
        if ( rc == 0 )
        {
            rc = VFSManagerMakeResolver ( vfs, ( VResolver** ) & mgr -> _pmgr, kfg );
            VFSManagerRelease ( vfs );
        }
        KConfigRelease ( kfg );
    }
    if ( rc != 0 )
        mgr -> _pmgr = NULL;

    return 0;
#endif
}
static rc_t TableWriterSeq_CollectStatistics(TableWriterSeq *self, const TableWriterData* primary_alignment_id)
{
    rc_t rc;
    int64_t mate[2] = {0, 0};
    uint64_t distance = 0;
    uint64_t count = 0;
    
    memcpy(mate, primary_alignment_id->buffer, sizeof(mate[0]) * primary_alignment_id->elements);
    if (mate[0] && mate[1]) {
        distance = (mate[0] < mate[1]) ? (mate[1] - mate[0]) : (mate[0] - mate[1]);
    }
    else
        return 0;
    if (self->stats == NULL) {
        rc = KVectorMake(&self->stats); if (rc) return rc;
    }
    rc = KVectorGetU64(self->stats, distance, &count);
    if (GetRCObject(rc) == rcItem && GetRCState(rc) == rcNotFound) {
        rc = KVectorSetU64(self->stats, distance, 1);
        if (rc == 0) ++self->statsCount;
    }
    else if (rc == 0) {
        ++count;
        rc = KVectorSetU64(self->stats, distance, count);
    }
    return rc;
}
Exemple #27
0
LIB_EXPORT rc_t CC ReferenceIteratorNextPos ( ReferenceIterator *self, bool skip_empty )
{
    rc_t rc = 0;
    if ( self == NULL )
        rc = RC( rcAlign, rcIterator, rcAccessing, rcSelf, rcNull );
    else
    {
        self->current_rec = NULL;
        if ( self->need_init )
        {
            rc = first_ref_iter_nxt_pos( self, skip_empty );
        }
        else
        {
            /* increment the current position */
            self->current_pos++;

            if ( self->current_pos <= self->last_pos )
            {
                /* jump over gaps, if requested ... */
                if ( self->depth == 0 && skip_empty )
                {
                    self->current_pos = self->nxt_avail_pos;
                }

                /* increment the internal alignment-iterator of every placement-record */
                inc_alignment_iterators( &self->spot_groups, self->current_pos );

                /* loop through the list to look if we have to remove records,
                   that do end before this new position */
                self->depth = remove_invalid_records( self->refobj, &self->spot_groups, self->current_pos );

                rc = fill_recordlist( self, self->current_pos );
                if ( rc == 0 )
                {
                    self->current_spot_group = NULL;
                    /* set our sights to the next position... */
                    rc = PlacementSetIteratorNextAvailPos ( self->pl_set_iter, &self->nxt_avail_pos, NULL );
                    if ( GetRCState( rc ) == rcDone )
                    {
                        if ( self->depth > 0 )
                        {
                            rc = 0;
                        }
                        else if ( !skip_empty )
                        {
                            if ( self->current_pos <= self->last_pos ) rc = 0;
                        }
                    }
                }
            }
            else
            {
                rc = SILENT_RC( rcAlign, rcIterator, rcAccessing, rcOffset, rcDone );
                clear_spot_group_list( &self->spot_groups );
            }
        }
    }
    return rc;
}
Exemple #28
0
rc_t BufferQRelease (const BufferQ *cself)
{
    BufferQ * self  = (BufferQ*)cself;
    rc_t rc = 0;
    if ( self != NULL )
    {
        if ( atomic32_dec_and_test (&self->refcount))
        {
	    const Buffer * b;
	    while (rc == 0)
	    {
		rc = BufferQPopBuffer (self, &b, NULL);
		BufferRelease (b);
	    }
/* this might need rework especially if KQueue changes */
	    if ((GetRCState(rc) == rcExhausted) && (GetRCObject(rc) == rcTimeout))
		rc = 0;
	    if (rc == 0)
	    {
		rc = KQueueRelease (self->q);
		if (rc == 0)
		{
		    free (self);
		    return 0;
		}
	    }
	    atomic32_inc (&((BufferQ*)self)->refcount);
        }
    }
    return rc;
}
Exemple #29
0
static
rc_t SRAConfigParse(const KXMLNode* xml_node, SRAConfigFlags* flags, char* errmsg)
{
    rc_t rc = 0;
    uint32_t i;
    char at[4096];
    size_t sz;
    char* attr_name[]         = { "run-directory", "SRA-archive",   "SRA-archive-lite",  "fastq",           "SFF" };
    SRAConfigFlags attr_val[] = { eSRAFuseRunDir,  eSRAFuseFileArc, eSRAFuseFileArcLite, eSRAFuseFileFastq, eSRAFuseFileSFF };

    if( *flags & eSRAFuseInitial ) {
        *flags = 0;
    }
    for(i = 0; rc == 0 && i < sizeof(attr_name)/sizeof(attr_name[0]); i++) {
        if( (rc = KXMLNodeReadAttrCString(xml_node, attr_name[i], at, sizeof(at), &sz)) == 0 ) {
            if( strcasecmp(at, "true") == 0 ) {
                *flags = *flags | attr_val[i];
            } else if( strcasecmp(at, "false") == 0 ) {
                *flags = *flags & ~(attr_val[i]);
            } else {
                strcpy(errmsg, "SRAConfig attribute ");
                strcat(errmsg,  attr_name[i]);
                strcat(errmsg, " value '");
                strcat(errmsg, at);
                strcat(errmsg, "'");
                rc = RC(rcExe, rcDoc, rcReading, rcData, rcInvalid);
            }
        } else if( GetRCState(rc) == rcNotFound ) {
            rc = 0;
        }
    }
    return rc;
}
Exemple #30
0
static rc_t walk_ref_iter( ReferenceIterator *ref_iter,
                           bool skip_empty,
                           bool nodebug )
{
    rc_t rc = 0;
    while( rc == 0 )
    {
        struct ReferenceObj const * refobj;
        INSDC_coord_zero first_pos;
        INSDC_coord_len len;
        rc = ReferenceIteratorNextReference( ref_iter, &first_pos, &len, &refobj );
        if ( rc == 0 && refobj != NULL )
        {
            const char *name;
            rc = ReferenceObj_SeqId( refobj, &name );
            if ( rc != 0 )
                LOGERR( klogInt, rc, "ReferenceObj_SeqId() failed" );
            else
            {
                OUTMSG(( "walking ref-iter on reference: >%s< ( from %u to %u )\n",
                         name, first_pos, first_pos + len - 1 ));
                rc = walk_ref_iter_reference( ref_iter, refobj, skip_empty, nodebug );
            }
        }
    }
    if ( GetRCState( rc ) == rcDone ) rc = 0;
    return rc;
}