rc_t CGWriterEvdInt_Make(const CGWriterEvdInt** cself, TEvidenceIntervalsData** data,
                         VDatabase* db, const ReferenceMgr* rmgr, const uint32_t options)
{
    rc_t rc = 0;
    CGWriterEvdInt* self;

    if( cself == NULL || db == NULL ) {
        return RC(rcExe, rcFormatter, rcConstructing, rcParam, rcNull);
    }
    self = calloc(1, sizeof(*self));
    if( self == NULL ) {
        rc = RC(rcExe, rcFormatter, rcConstructing, rcMemory, rcExhausted);
    } else {
        if( (rc = TableWriterAlgn_Make(&self->writer, db, ewalgn_tabletype_EvidenceInterval, 0)) == 0 ) {
            self->algn.read_start.buffer = &self->match.read_start;
            self->algn.read_len.buffer = &self->match.read_len;
            self->algn.has_ref_offset.buffer = self->match.has_ref_offset;
            self->algn.ref_offset.buffer = self->match.ref_offset;
            self->algn.has_mismatch.buffer = self->match.has_mismatch;
            self->algn.mismatch.buffer = self->match.mismatch;
            self->algn.ref_id.buffer = &self->match.ref_id;
            self->algn.ref_id.elements = 1;
            self->algn.ref_start.buffer = &self->match.ref_start;
            self->algn.ref_start.elements = 1;
            self->match.ref_orientation = false;
            self->algn.ref_orientation.buffer = &self->match.ref_orientation;
            self->algn.ref_orientation.elements = 1;
            self->algn.mapq.buffer = &self->match.mapq;
            self->algn.mapq.elements = 1;
            self->algn.alingment_ids.buffer = self->dnbs_ids;
            self->rmgr = rmgr;
            *data = &self->data;
        }
    }
    if( rc == 0 ) {
        *cself = self;
    } else {
        CGWriterEvdInt_Whack(self, false, NULL);
    }
    return rc;
}
Example #2
0
rc_t CGWriterAlgn_Make(const CGWriterAlgn** cself, TMappingsData** data, VDatabase* db, const ReferenceMgr* rmgr,
                       uint32_t min_mapq, bool single_mate, uint32_t cluster_size)
{
    rc_t rc = 0;
    CGWriterAlgn* self;

    if( cself == NULL || db == NULL ) {
        return RC(rcExe, rcFormatter, rcConstructing, rcParam, rcNull);
    }
    self = calloc(1, sizeof(*self));
    if( self == NULL ) {
        rc = RC(rcExe, rcFormatter, rcConstructing, rcMemory, rcExhausted);
    } else {
        if( (rc = TableWriterAlgn_Make(&self->primary, db,
                            ewalgn_tabletype_PrimaryAlignment, ewalgn_co_SEQ_SPOT_ID | ewalgn_co_unsorted)) != 0 ){
            LOGERR(klogErr, rc, "primary alignment table");
        } else if( (rc = TableWriterAlgn_Make(&self->secondary, db,
                            ewalgn_tabletype_SecondaryAlignment, ewalgn_co_SEQ_SPOT_ID | ewalgn_co_unsorted)) != 0 ) {
            LOGERR(klogErr, rc, "secondary alignment table");
        } else {
            int i;
            /* interconnect buffers */
            for(i = 0; i < CG_MAPPINGS_MAX; i++) {
                self->algn[i].seq_spot_id.buffer = &self->match[i].seq_spot_id;
                self->algn[i].seq_spot_id.elements = 1;
                
                self->algn[i].seq_read_id.buffer = &self->match[i].seq_read_id;
                self->algn[i].seq_read_id.elements = 1;

                self->algn[i].read_start.buffer = &self->match[i].read_start;
                
                self->algn[i].read_len.buffer = &self->match[i].read_len;
                
                self->algn[i].has_ref_offset.buffer = self->match[i].has_ref_offset;
                
                self->algn[i].ref_offset.buffer = self->match[i].ref_offset;
                
                self->algn[i].ref_offset_type.buffer = self->match[i].ref_offset_type;
                
                self->algn[i].ref_id.buffer = &self->match[i].ref_id;
                
                self->algn[i].ref_start.buffer = &self->match[i].ref_start;
                
                self->algn[i].has_mismatch.buffer = self->match[i].has_mismatch;
                
                self->algn[i].mismatch.buffer = self->match[i].mismatch;
                
                self->algn[i].ref_orientation.buffer = &self->match[i].ref_orientation;
                self->algn[i].ref_orientation.elements = 1;
                
                self->algn[i].mapq.buffer = &self->match[i].mapq;
                self->algn[i].mapq.elements = 1;
                
                self->algn[i].mate_ref_orientation.buffer = &self->match[i].mate_ref_orientation;
                self->algn[i].mate_ref_orientation.elements = 1;
                
                self->algn[i].mate_ref_id.buffer = &self->match[i].mate_ref_id;
                self->algn[i].mate_ref_id.elements = 1;
                
                self->algn[i].mate_ref_pos.buffer = &self->match[i].mate_ref_pos;
                self->algn[i].mate_ref_pos.elements = 1;
                
                self->algn[i].template_len.buffer = &self->match[i].template_len;
                self->algn[i].template_len.elements = 1;
            }
            self->rmgr = rmgr;
            self->min_mapq = min_mapq;
            self->single_mate = single_mate;
            global_cluster_size = cluster_size;
            *data = &self->data;
        }
    }
    if( rc == 0 ) {
        *cself = self;
    } else {
        CGWriterAlgn_Whack(self, false, NULL, NULL);
    }
    return rc;
}