regionkey.h

Go to the documentation of this file.

// RegionKey
//
// regionkey.h
//
// @category   Libraries
// @author     Nicola Asuni <nicola.asuni@genomicsplc.com>
// @copyright  2017-2018 GENOMICS plc
// @license    MIT (see LICENSE)
// @link       https://github.com/genomicsplc/regionkey
//
// LICENSE
//
// Copyright (c) 2017-2018 GENOMICS plc
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#ifndef VARIANTKEY_REGIONKEY_H
#define VARIANTKEY_REGIONKEY_H

#include <stdio.h>
#include "nrvk.h"

#define RK_MAX_POS       0x000000000FFFFFFF  
#define RKMASK_CHROM     0xF800000000000000  
#define RKMASK_STARTPOS  0x07FFFFFF80000000  
#define RKMASK_ENDPOS    0x000000007FFFFFF8  
#define RKMASK_STRAND    0x0000000000000006  
#define RKMASK_NOPOS     0xF800000000000007  
#define RKSHIFT_CHROM     59 
#define RKSHIFT_STARTPOS  31 
#define RKSHIFT_ENDPOS     3 
#define RKSHIFT_STRAND     1 

#define RK_CHROM    ((rk & RKMASK_CHROM) >> RKSHIFT_CHROM)       
#define RK_STARTPOS ((rk & RKMASK_STARTPOS) >> RKSHIFT_STARTPOS) 
#define RK_ENDPOS   ((rk & RKMASK_ENDPOS) >> RKSHIFT_ENDPOS)     
#define RK_STRAND   ((rk & RKMASK_STRAND) >> RKSHIFT_STRAND)     


typedef struct regionkey_t
{
    uint8_t chrom;     
    uint32_t startpos; 
    uint32_t endpos;   
    uint8_t strand;    
} regionkey_t;

typedef struct regionkey_rev_t
{
    char chrom[3];     
    uint32_t startpos; 
    uint32_t endpos;   
    int8_t strand;     
} regionkey_rev_t;

static inline uint8_t encode_region_strand(int8_t strand)
{
    static const uint8_t map[] = {2, 0, 1, 0};
    return map[((uint8_t)(++strand) & 3)];
}

static inline int8_t decode_region_strand(uint8_t strand)
{
    static const int8_t map[] = {0, 1, -1, 0};
    return map[(strand & 3)];
}

static inline uint64_t encode_regionkey(uint8_t chrom, uint32_t startpos, uint32_t endpos, uint8_t strand)
{
    return (((uint64_t)chrom << RKSHIFT_CHROM) | ((uint64_t)startpos << RKSHIFT_STARTPOS) | ((uint64_t)endpos << RKSHIFT_ENDPOS) | ((uint64_t)strand << RKSHIFT_STRAND));
}

static inline uint8_t extract_regionkey_chrom(uint64_t rk)
{
    return (uint8_t)RK_CHROM;
}

static inline uint32_t extract_regionkey_startpos(uint64_t rk)
{
    return (uint32_t)RK_STARTPOS;
}

static inline uint32_t extract_regionkey_endpos(uint64_t rk)
{
    return (uint32_t)RK_ENDPOS;
}

static inline uint8_t extract_regionkey_strand(uint64_t rk)
{
    return (uint8_t)RK_STRAND;
}

static inline void decode_regionkey(uint64_t code, regionkey_t *rk)
{
    rk->chrom = extract_regionkey_chrom(code);
    rk->startpos = extract_regionkey_startpos(code);
    rk->endpos = extract_regionkey_endpos(code);
    rk->strand = extract_regionkey_strand(code);
}

static inline void reverse_regionkey(uint64_t rk, regionkey_rev_t *rev)
{
    decode_chrom(extract_regionkey_chrom(rk), rev->chrom);
    rev->startpos = extract_regionkey_startpos(rk);
    rev->endpos = extract_regionkey_endpos(rk);
    rev->strand = decode_region_strand(extract_regionkey_strand(rk));
}

static inline uint64_t regionkey(const char *chrom, size_t sizechrom, uint32_t startpos, uint32_t endpos, int8_t strand)
{
    return encode_regionkey(encode_chrom(chrom, sizechrom), startpos, endpos, encode_region_strand(strand));
}

static inline uint64_t extend_regionkey(uint64_t rk, uint32_t size)
{
    uint64_t startpos = RK_STARTPOS;
    uint64_t endpos = RK_ENDPOS;
    startpos = ((size >= startpos) ? 0 : (startpos - size));
    endpos = (((RK_MAX_POS - endpos) <= size) ? RK_MAX_POS : (endpos + size));
    return ((rk & RKMASK_NOPOS) | (startpos << RKSHIFT_STARTPOS) | (endpos << RKSHIFT_ENDPOS));
}

static inline size_t regionkey_hex(uint64_t rk, char *str)
{
    return hex_uint64_t(rk, str);
}

static inline uint64_t parse_regionkey_hex(const char *rs)
{
    return parse_hex_uint64_t(rs);
}

static inline uint64_t get_regionkey_chrom_startpos(uint64_t rk)
{
    return (rk >> RKSHIFT_STARTPOS);
}

static inline uint64_t get_regionkey_chrom_endpos(uint64_t rk)
{
    return (((rk & RKMASK_CHROM) >> RKSHIFT_STARTPOS) | extract_regionkey_endpos(rk));
}

static inline uint8_t are_overlapping_regions(uint8_t a_chrom, uint32_t a_startpos, uint32_t a_endpos, uint8_t b_chrom, uint32_t b_startpos, uint32_t b_endpos)
{
    return (uint8_t)((a_chrom == b_chrom) && (a_startpos < b_endpos) && (a_endpos > b_startpos));
}

static inline uint8_t are_overlapping_region_regionkey(uint8_t chrom, uint32_t startpos, uint32_t endpos, uint64_t rk)
{
    return (uint8_t)((chrom == extract_regionkey_chrom(rk)) && (startpos < extract_regionkey_endpos(rk)) && (endpos > extract_regionkey_startpos(rk)));
}

static inline uint8_t are_overlapping_regionkeys(uint64_t rka, uint64_t rkb)
{
    return (uint8_t)((extract_regionkey_chrom(rka) == extract_regionkey_chrom(rkb)) && (extract_regionkey_startpos(rka) < extract_regionkey_endpos(rkb)) && (extract_regionkey_endpos(rka) > extract_regionkey_startpos(rkb)));
}

static inline uint8_t are_overlapping_variantkey_regionkey(nrvk_cols_t nvc, uint64_t vk, uint64_t rk)
{
    return (uint8_t)((extract_variantkey_chrom(vk) == extract_regionkey_chrom(rk)) && (extract_variantkey_pos(vk) < extract_regionkey_endpos(rk)) && (get_variantkey_endpos(nvc, vk) > extract_regionkey_startpos(rk)));
}

static inline uint64_t variantkey_to_regionkey(nrvk_cols_t nvc, uint64_t vk)
{
    return ((vk & VKMASK_CHROMPOS) | ((uint64_t)get_variantkey_endpos(nvc, vk) << RKSHIFT_ENDPOS));
}

#endif  // VARIANTKEY_REGIONKEY_H