kv_vidctx_t *
kv_vidctx_init(const char *rootdir, kv_emit_f emit, const char *dbgdir,
kv_flags_t flags)
{
kv_vidctx_t *kvp;
if (kv_init(rootdir) != 0) {
warnx("failed to initialize masks");
return (NULL);
}
if ((kvp = calloc(1, sizeof (*kvp))) == NULL) {
warn("calloc");
return (NULL);
}
kvp->kv_last_start = -1;
kvp->kv_emit = emit;
kvp->kv_flags = flags;
if (dbgdir != NULL)
(void) strlcpy(kvp->kv_dbgdir, dbgdir, sizeof (kvp->kv_dbgdir));
return (kvp);
}
void test_forest_serialization() {
test_header();
ET_problem prob;
ET_params params;
ET_forest *forest, *forest2;
uchar_vec buffer;
unsigned char *mobile_buffer;
float vector[] = {3, 1, 1, 6, 6, 2};
kv_init(buffer);
problem_init(&prob, big_vectors, big_labels);
EXTRA_TREE_DEFAULT_REGR_PARAMS(prob, params);
params.number_of_trees = 100;
params.number_of_features_tested = 1;
params.select_features_with_replacement = true;
forest = ET_forest_build(&prob, ¶ms);
ET_forest_dump(forest, &buffer, true);
fprintf(stderr, "forest dump: %zu bytes\n", kv_size(buffer));
mobile_buffer = buffer.a;
forest2 = ET_forest_load(&mobile_buffer);
forest2->params = forest->params; // FIXME
fprintf(stderr, "orig forest pred: %g\n",
ET_forest_predict(forest, vector));
fprintf(stderr, "cloned forest pred: %g\n",
ET_forest_predict(forest2, vector));
kv_destroy(buffer);
ET_forest_destroy(forest);
ET_forest_destroy(forest2);
free(forest);
free(forest2);
}
static int
cmd_starts(int argc, char *argv[])
{
video_t *vp;
int rv, last;
if (kv_init(dirname((char *)kv_arg0)) != 0) {
warnx("failed to initialize masks");
return (EXIT_FAILURE);
}
if (argc < 1) {
warnx("missing input file");
return (EXIT_USAGE);
}
if ((vp = video_open(argv[0])) == NULL)
return (EXIT_FAILURE);
last = 0;
rv = video_iter_frames(vp, check_start_frame, &last);
video_free(vp);
return (rv);
}
strings_v
shape_load_names(const char* filename, const char* colname) {
DBFHandle hDBF;
strings_v col;
kv_init(col);
hDBF = DBFOpen( filename, "rb" );
if( hDBF == NULL ) {
fprintf(stderr, "DBFOpen(%s,\"r\") failed.\n", filename );
return col;
}
uint32_t fid = DBFGetFieldIndex(hDBF, colname);
for(uint32_t i = 0; i < DBFGetRecordCount(hDBF); i++ ) {
char* str = (char *) DBFReadStringAttribute(hDBF, i, fid);
if(str != NULL)
kv_push(char*, col, strdup(str));
else
kv_push(char*, col, NULL);
}
DBFClose( hDBF );
return col;
}
int main(){
void * kv_obj = kv_init(":memory:");
test(kv_obj);
return 0;
}
int do_grep() {
#ifdef DEBUGa
printf("[!]do_grep\n");
#endif
BamInfo_t *pbam;
kh_cstr_t BamID;
khiter_t ki, bami;
kstring_t ks1 = { 0, 0, NULL };
kstring_t ks2 = { 0, 0, NULL };
kstring_t ks3 = { 0, 0, NULL };
samFile *in;
bam_hdr_t *h;
hts_idx_t *idx;
bam1_t *b, *d, *d2, *bR1, *bR2, *bR3;
bR1 = bam_init1(); bR2 = bam_init1(); bR3 = bam_init1();
//htsFile *out;
//hts_opt *in_opts = NULL, *out_opts = NULL;
int r = 0, exit_code = 0;
kvec_t(bam1_t) R1, R2, RV;
pierCluster_t *pierCluster;
//samdat_t tmp_samdat;
FILE *fs = fopen("./test.txt","w");
for (bami = kh_begin(bamNFOp); bami != kh_end(bamNFOp); ++bami) {
//printf(">[%d]:\n",bami);
if (kh_exist(bamNFOp, bami)) {
kv_init(R1); kv_init(R2); kv_init(RV);
//tmp_samdat = (const samdat_t){ 0 };
//memset(&tmp_samdat,0,sizeof(samdat_t));
//printf("-[%d]:\n",bami);
BamID = kh_key(bamNFOp, bami);
pbam = &kh_value(bamNFOp, bami);
fprintf(stderr, "%u [%s]=%s\t%u %u\n",bami,BamID,pbam->fileName,pbam->insertSize,pbam->SD);
in = sam_open(pbam->fileName, "r");
if (in == NULL) {
fprintf(stderr, "[x]Error opening \"%s\"\n", pbam->fileName);
return EXIT_FAILURE;
}
h = sam_hdr_read(in);
/* out = hts_open("-", "w");
if (out == NULL) {
fprintf(stderr, "[x]Error opening standard output\n");
return EXIT_FAILURE;
}
if (sam_hdr_write(out, h) < 0) {
fprintf(stderr, "[!]Error writing output header.\n");
exit_code = 1;
}
*/
int8_t *ChrIsHum;
if (h == NULL) {
fprintf(stderr, "[x]Couldn't read header for \"%s\"\n", pbam->fileName);
return EXIT_FAILURE;
} else {
ChrIsHum = malloc(h->n_targets * sizeof(int8_t));
for (int32_t i=0; i < h->n_targets; ++i) {
//ChrIsHum[i] = -1;
ki = kh_get(chrNFO, chrNFOp, h->target_name[i]);
if (ki == kh_end(chrNFOp)) {
errx(4,"[x]Cannot find ChrID for [%s] !",h->target_name[i]);
} else {
ChrInfo_t * tmp = &kh_value(chrNFOp, ki);
ChrIsHum[i] = tmp->isHum;
//printf(">>> %d Chr:%s %d\n",i,h->target_name[i],ChrIsHum[i]);
}
}
}
h->ignore_sam_err = 0;
b = bam_init1();
d = bam_init1();
d2 = bam_init1();
if ((idx = sam_index_load(in, pbam->fileName)) == 0) {
fprintf(stderr, "[E::%s] fail to load the BAM index\n", __func__);
return 1;
}
pierCluster = sam_plp_init();
while ((r = sam_read1(in, h, b)) >= 0) {
int8_t flag = false;
const bam1_core_t *c = &b->core;
if (c->flag & BAM_FSECONDARY) continue;
if (c->n_cigar) {
uint32_t *cigar = bam_get_cigar(b);
for (int i = 0; i < c->n_cigar; ++i) {
if (bam_cigar_opchr(cigar[i])=='S') { // soft clipping
if ( bam_cigar_oplen(cigar[i]) >= myConfig.minGrepSlen ) {
flag = true;
}
}
}
}
if (flag && ChrIsHum[c->tid]) { // Now, skip Virus items.
//bam_copy1(bR1, b);
flag = 0; // recycle
//int enoughMapQ = 0;
//kstring_t ks = { 0, 0, NULL };
/*if (sam_format1(h, b, &ks1) < 0) {
fprintf(stderr, "Error writing output.\n");
exit_code = 1;
break;
} else*/ if ((c->mtid == c->tid && ChrIsHum[c->tid]) || (ChrIsHum[c->tid] ^ ChrIsHum[c->mtid])) { // Only grep those mapped on same Human ChrID, or diff species/一方在病毒的情况.
//printf(">[%s]\n",ks_str(&ks1));
flag |= 1;
//tmp_samdat.b = bam_dup1(b);
//kv_push(samdat_t,R1,tmp_samdat);
/*if (checkMapQ(ChrIsHum, b, true)) {
++enoughMapQ;
}*/
}
if (getPairedSam(in, idx, b, d) != 0) {
flag &= ~1;
continue;
} else {
flag |= 2;
/*if (checkMapQ(ChrIsHum, d, false)) {
++enoughMapQ;
}*/
/*if (c->flag & BAM_FSECONDARY) {
if (getPairedSam(in, idx, d, d2) == 0) {
//sam_format1(h, d2, &ks3);
flag |= 4;
if (checkMapQ(ChrIsHum, d2, false)) {
++enoughMapQ;
}
}
}*/
}
/*
对于 BAM_FSECONDARY(256) 的 Read，跳两次 与 读 SA 项，效果一样。
>[sf95_Ref_48245009_48245108_48245208_Vir_-_2000_2044_R_100_90 353 chr2 13996555 0 50S40M chr18 48245109 0ACACAACAATGTTCCGGAGACTCTAAGGCCTCCCGATACAGAGCAGAGGCCACACACACACACACCATGGAATACTATTCAGCCAAAAAA CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC NM:i:0 MD:Z:40 AS:i:40 XS:i:40 RG:Z:Fsimout_mB SA:Z:rgi|59585|emb|X04615.1|,2000,-,40S46M4S,60,0; YC:Z:CT YD:Z:f]
-[sf95_Ref_48245009_48245108_48245208_Vir_-_2000_2044_R_100_90 177 chr18 48245109 9 40S50M gi|59585|emb|X04615.1|2000 0 GTTCCGGAGACTCTAAGGCCTCCCGATACAGAGCAGAGGCCACACACACACACACCATGGAATACTATTCAGCCAAAAAAAGGAATTCAA CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC NM:i:0 MD:Z:50 AS:i:50 XS:i:46 RG:Z:Fsimout_mB SA:Z:rgi|59585|emb|X04615.1|,2000,+,50S40M,9,0; YC:Z:GA YD:Z:f]
+[sf95_Ref_48245009_48245108_48245208_Vir_-_2000_2044_R_100_90 113 gi|59585|emb|X04615.1| 2000 60 40S46M4S chr18 48245109 0 TTTTTTGGCTGAATAGTATTCCATGGTGTGTGTGTGTGTGGCCTCTGCTCTGTATCGGGAGGCCTTAGAGTCTCCGGAACATTGTTGTGT CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC NM:i:0 MD:Z:46 AS:i:46 XS:i:27 RG:Z:Fsimout_mB SA:Z:fchr2,13996555,+,50S40M,0,0; YC:Z:CT YD:Z:r]
*/
/*if (sam_format1(h, d, &ks2) < 0) {
fprintf(stderr, "Error writing output.\n");
exit_code = 1;
break;
}*/
if (((flag & 3) == 3) /*&& enoughMapQ >= myConfig.samples*/) {
/*printf(">%d[%s]\n",checkMapQ(ChrIsHum, b, true),ks_str(&ks1));
printf("-%d[%s]\n",checkMapQ(ChrIsHum, d, false),ks_str(&ks2));
if (flag & 4) {
printf("+%d[%s]\n",checkMapQ(ChrIsHum, d2, false),ks_str(&ks3));
}
printf("<--%d\n",enoughMapQ);*/
if (sam_plp_push(ChrIsHum, pierCluster, b) == 0) {
//printf("--HumRange=%s:%d-%d\n", h->target_name[(pierCluster->HumanRange).tid], (pierCluster->HumanRange).pos, (pierCluster->HumanRange).endpos);
if ((!ChrIsHum[(d->core).tid]) && (flag & 2)) sam_plp_push(ChrIsHum, pierCluster, d);
//if ((!ChrIsHum[(d2->core).tid]) && (flag & 4)) sam_plp_push(ChrIsHum, pierCluster, d2);
} else {
//print
fprintf(fs,"[%s]\nHumRange=%s:%d-%d\n", BamID, h->target_name[(pierCluster->HumanRange).tid], (pierCluster->HumanRange).pos, (pierCluster->HumanRange).endpos);
fprintf(fs,"VirRange=%s:%d-%d\n", h->target_name[(pierCluster->VirusRange).tid], (pierCluster->VirusRange).pos, (pierCluster->VirusRange).endpos);
for (size_t i=0; i<kv_size(pierCluster->Reads);++i) {
bam1_t *bi = kv_A(pierCluster->Reads, i);
if (sam_format1(h, bi, &ks1) < 0) {
fprintf(stderr, "Error writing output.\n");
exit_code = 1;
break;
} else {
fprintf(fs,"%s\n",ks1.s);
}
}
fprintf(fs,"\n");
//printf("HumRange=%s:%d-%d\n", h->target_name[(pierCluster->HumanRange).tid], (pierCluster->HumanRange).pos, (pierCluster->HumanRange).endpos);
//fflush(fs);
sam_plp_dectroy(pierCluster);
pierCluster = sam_plp_init();
}
}
}
/*char *qname = bam_get_qname(b);
if (sam_write1(out, h, b) < 0) {
fprintf(stderr, "[x]Error writing output.\n");
exit_code = 1;
break;
}*/
}
/* r = sam_close(out); // stdout can only be closed once
if (r < 0) {
fprintf(stderr, "Error closing output.\n");
exit_code = 1;
}
*/
hts_idx_destroy(idx);
bam_destroy1(b);
bam_destroy1(d);
bam_destroy1(d2);
bam_hdr_destroy(h);
r = sam_close(in);
free(ChrIsHum);
#ifdef DEBUGa
fflush(NULL);
//pressAnyKey();
#endif
sam_plp_dectroy(pierCluster);
//printf("<[%d]:\n",bami);
}
}
fclose(fs);
getPairedSam(NULL, NULL, NULL, NULL); // sam_close(fp2);
//printf("---[%d]---\n",exit_code);
bam_destroy1(bR1); bam_destroy1(bR2); bam_destroy1(bR3);
ks_release(&ks1);
ks_release(&ks2);
ks_release(&ks3);
return exit_code;
}
/*
* 函 数:libkv_init
* 功 能:初始化libkv库
* 参 数:
* 功 能:
* 返回值:
*/
void libkv_init()
{
assert(kv_init(NULL) == ERR_NONE);
}
int
exec_which(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
char pathabs[MAXPATHLEN];
char *p, *path, *match, *savedpath;
int ret = EPKG_OK, retcode = EX_SOFTWARE;
int ch, i;
int res, pathlen = 0;
bool orig = false;
bool glob = false;
bool search = false;
bool search_s = false;
charlist patterns;
struct option longopts[] = {
{ "glob", no_argument, NULL, 'g' },
{ "origin", no_argument, NULL, 'o' },
{ "path-search", no_argument, NULL, 'p' },
{ "quiet", no_argument, NULL, 'q' },
{ NULL, 0, NULL, 0 },
};
path = NULL;
while ((ch = getopt_long(argc, argv, "+gopq", longopts, NULL)) != -1) {
switch (ch) {
case 'g':
glob = true;
break;
case 'o':
orig = true;
break;
case 'p':
search_s = true;
break;
case 'q':
quiet = true;
break;
default:
usage_which();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
usage_which();
return (EX_USAGE);
}
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
return (EX_IOERR);
}
if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get a read lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (search_s) {
if ((path = getenv("PATH")) == NULL) {
printf("$PATH is not set, falling back to non-search behaviour\n");
search_s = false;
} else {
pathlen = strlen(path) + 1;
}
}
while (argc >= 1) {
kv_init(patterns);
retcode = EX_SOFTWARE;
if (search_s) {
if ((argv[0][0] == '.') || (argv[0][0] == '/')) {
search = false;
} else {
search = true;
if (strlen(argv[0]) >= FILENAME_MAX) {
retcode = EX_USAGE;
goto cleanup;
}
p = malloc(pathlen);
if (p == NULL) {
retcode = EX_OSERR;
goto cleanup;
}
strlcpy(p, path, pathlen);
match = NULL;
savedpath=p;
for (;;) {
res = get_match(&match, &p, argv[0]);
if (p == NULL)
break;
if (res == (EX_USAGE)) {
printf("%s was not found in PATH, falling back to non-search behaviour\n", argv[0]);
search = false;
} else if (res == (EX_OSERR)) {
retcode = EX_OSERR;
free(savedpath);
goto cleanup;
} else {
pkg_absolutepath(match, pathabs, sizeof(pathabs));
/* ensure not not append twice an entry if PATH is messy */
if (already_in_list(&patterns, pathabs))
continue;
kv_push(char *, patterns, strdup(pathabs));
free(match);
}
}
free(savedpath);
}
}
if (!glob && !search) {
pkg_absolutepath(argv[0], pathabs, sizeof(pathabs));
kv_push(char *, patterns, strdup(pathabs));
} else if (!search) {
if (strlcpy(pathabs, argv[0], sizeof(pathabs)) >= sizeof(pathabs)) {
retcode = EX_USAGE;
goto cleanup;
}
}
for (i = 0; i < kv_size(patterns); i++) {
if ((it = pkgdb_query_which(db, kv_A(patterns, i), glob)) == NULL) {
retcode = EX_IOERR;
goto cleanup;
}
pkg = NULL;
while ((ret = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC)) == EPKG_OK) {
retcode = EX_OK;
if (quiet && orig)
pkg_printf("%o\n", pkg);
else if (quiet && !orig)
pkg_printf("%n-%v\n", pkg, pkg);
else if (!quiet && orig)
pkg_printf("%S was installed by package %o\n", kv_A(patterns, i), pkg);
else if (!quiet && !orig)
pkg_printf("%S was installed by package %n-%v\n", kv_A(patterns, i), pkg, pkg);
}
if (retcode != EX_OK && !quiet)
printf("%s was not found in the database\n", kv_A(patterns, i));
pkg_free(pkg);
pkgdb_it_free(it);
}
kv_destroy(patterns);
argc--;
argv++;
}
cleanup:
pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
pkgdb_close(db);
return (retcode);
}
shapes_v*
shapes_new() {
shapes_v* shapes = calloc(1,sizeof(shapes_v));
kv_init(*shapes);
return shapes;
}
int
exec_clean(int argc, char **argv)
{
struct pkgdb *db = NULL;
kh_sum_t *sumlist = NULL;
dl_list dl;
const char *cachedir;
bool all = false;
int retcode;
int ch;
int cachefd = -1;
size_t total = 0;
char size[8];
char *cksum;
struct pkg_manifest_key *keys = NULL;
#ifdef HAVE_CAPSICUM
cap_rights_t rights;
#endif
struct option longopts[] = {
{ "all", no_argument, NULL, 'a' },
{ "dry-run", no_argument, NULL, 'n' },
{ "quiet", no_argument, NULL, 'q' },
{ "yes", no_argument, NULL, 'y' },
{ NULL, 0, NULL, 0 },
};
while ((ch = getopt_long(argc, argv, "+anqy", longopts, NULL)) != -1) {
switch (ch) {
case 'a':
all = true;
break;
case 'n':
dry_run = true;
break;
case 'q':
quiet = true;
break;
case 'y':
yes = true;
break;
default:
usage_clean();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
cachedir = pkg_object_string(pkg_config_get("PKG_CACHEDIR"));
cachefd = open(cachedir, O_DIRECTORY);
if (cachefd == -1) {
warn("Impossible to open %s", cachedir);
return (EX_IOERR);
}
retcode = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_REPO);
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to clean old packages");
close(cachefd);
return (EX_NOPERM);
} else if (retcode == EPKG_ENODB) {
warnx("No package database installed. Nothing to do!");
close(cachefd);
return (EX_OK);
} else if (retcode != EPKG_OK) {
warnx("Error accessing the package database");
close(cachefd);
return (EX_SOFTWARE);
}
retcode = EX_SOFTWARE;
if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK) {
close(cachefd);
return (EX_IOERR);
}
if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
pkgdb_close(db);
close(cachefd);
warnx("Cannot get a read lock on a database, it is locked by "
"another process");
return (EX_TEMPFAIL);
}
#ifdef HAVE_CAPSICUM
cap_rights_init(&rights, CAP_READ, CAP_LOOKUP, CAP_FSTATFS,
CAP_FSTAT, CAP_UNLINKAT);
if (cap_rights_limit(cachefd, &rights) < 0 && errno != ENOSYS ) {
warn("cap_rights_limit() failed");
close(cachefd);
return (EX_SOFTWARE);
}
if (cap_enter() < 0 && errno != ENOSYS) {
warn("cap_enter() failed");
close(cachefd);
return (EX_SOFTWARE);
}
#endif
kv_init(dl);
/* Build the list of out-of-date or obsolete packages */
pkg_manifest_keys_new(&keys);
recursive_analysis(cachefd, db, cachedir, cachedir, &dl, &sumlist, all,
&total);
if (sumlist != NULL) {
kh_foreach_value(sumlist, cksum, free(cksum));
kh_destroy_sum(sumlist);
}
if (kv_size(dl) == 0) {
if (!quiet)
printf("Nothing to do.\n");
retcode = EX_OK;
goto cleanup;
}
humanize_number(size, sizeof(size), total, "B",
HN_AUTOSCALE, HN_IEC_PREFIXES);
if (!quiet)
printf("The cleanup will free %s\n", size);
if (!dry_run) {
if (query_yesno(false,
"\nProceed with cleaning the cache? ")) {
retcode = delete_dellist(cachefd, cachedir, &dl, kv_size(dl));
}
} else {
retcode = EX_OK;
}
cleanup:
pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
pkgdb_close(db);
pkg_manifest_keys_free(keys);
free_dellist(&dl);
if (cachefd != -1)
close(cachefd);
return (retcode);
}
static aln_v align_read(const kseq_t *read,
const kseq_v targets,
const align_config_t *conf)
{
kseq_t *r;
const int32_t read_len = read->seq.l;
aln_v result;
kv_init(result);
kv_resize(aln_t, result, kv_size(targets));
uint8_t *read_num = calloc(read_len, sizeof(uint8_t));
for(size_t k = 0; k < read_len; ++k)
read_num[k] = conf->table[(int)read->seq.s[k]];
// Align to each target
kswq_t *qry = NULL;
for(size_t j = 0; j < kv_size(targets); j++) {
// Encode target
r = &kv_A(targets, j);
uint8_t *ref_num = calloc(r->seq.l, sizeof(uint8_t));
for(size_t k = 0; k < r->seq.l; ++k)
ref_num[k] = conf->table[(int)r->seq.s[k]];
aln_t aln;
aln.target_idx = j;
aln.loc = ksw_align(read_len, read_num,
r->seq.l, ref_num,
conf->m,
conf->mat,
conf->gap_o,
conf->gap_e,
KSW_XSTART,
&qry);
ksw_global(aln.loc.qe - aln.loc.qb + 1,
&read_num[aln.loc.qb],
aln.loc.te - aln.loc.tb + 1,
&ref_num[aln.loc.tb],
conf->m,
conf->mat,
conf->gap_o,
conf->gap_e,
50, /* TODO: Magic number - band width */
&aln.n_cigar,
&aln.cigar);
aln.nm = 0;
size_t qi = aln.loc.qb, ri = aln.loc.tb;
for(size_t k = 0; k < aln.n_cigar; k++) {
const int32_t oplen = bam_cigar_oplen(aln.cigar[k]),
optype = bam_cigar_type(aln.cigar[k]);
if(optype & 3) { // consumes both - check for mismatches
for(size_t j = 0; j < oplen; j++) {
if(UNLIKELY(read_num[qi + j] != ref_num[ri + j]))
aln.nm++;
}
} else {
aln.nm += oplen;
}
if(optype & 1) qi += oplen;
if(optype & 2) ri += oplen;
}
kv_push(aln_t, result, aln);
free(ref_num);
}
free(qry);
free(read_num);
ks_introsort(dec_score, kv_size(result), result.a);
return result;
}
void sys_init(void)
{
#if 0
uart_init();
deg_str("AC309N-C\n");
#endif
core_power_on();
OTP_CLK_DIV2();
DECODER_DIV2();
sys_clk_div(4);//SYSTEM_CLK_DIV4();
set_vol_tab_ptr(analog_vol_tab, digital_vol_tab);
#if (NO_DISP != monitor)
init_display();
#endif
sd_speed_init(0,100);
//#if SDMMC_CMD_MODE
// sd_chk_ctl(SET_SD_H_CHK);
//#endif
init_port_sd();
kv_init(); ///按键音初始化函数
#if RTC_ENABLE
if (rtc_init()) //RTC初始化，检测是否闹钟开机
{
work_mode = RTC_MODE;
}
#else
{
u8 rtc_reg = read_rtc_reg();
if (rtc_reg & BIT(7)) //检测是否掉电
{
rtc_reg &= ~(BIT(7)); //清零PDFLAG
write_rtc_reg(rtc_reg);
#if USE_RTC_RAM
#if RTC_ENABLE
reset_rtc_ram();
#else
{
u8 i;
for (i = 0; i < 64; i++)
{
write_rtc_ram(i, 0);
}
}
#endif ///<RTC_ENABLE
#endif ///<USE_RTC_RAM
}
}
#endif
key_init();
bsp_init();
#if ECHO_ENABLE
dec_analog_vol_sel(1);
echo_ptr = (REVERB_CTL _xdata *)get_echo_var_ptr(1);
encode_msg = (ENCODE_MSG _xdata *)get_encode_msg_ptr();
app_echo.strong = 150;
app_echo.deep = 40;
#else
dec_analog_vol_sel(0);
get_echo_var_ptr(0);///<传参0，不适用混响功能
#endif
interrupt_init(15, rtcisr);
interrupt_init(3, timer3isr);
interrupt_init(0, timer0isr);
enable_interrupt();
}
void case_cmd_lrange_found()
{
answer_t *ans;
answer_iter_t *iter;
answer_value_t *value;
CU_ASSERT(kv_init(NULL) == ERR_NONE);
ans = kv_ask("lpush mylist a b c", strlen("lpush mylist a b c"));
CU_ASSERT(ans->errnum == ERR_NONE);
answer_release(ans);
ans = kv_ask("lrange mylist 0 0", strlen("lrange mylist 0 0"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
iter = answer_get_iter(ans, ANSWER_HEAD);
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "c");
CU_ASSERT_PTR_EQUAL(answer_value_to_string(answer_next(iter)), NULL);
answer_release_iter(iter);
answer_release(ans);
ans = kv_ask("lrange mylist 0 2", strlen("lrange mylist 0 2"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
iter = answer_get_iter(ans, ANSWER_HEAD);
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "c");
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "b");
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a");
value = answer_next(iter);
CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL);
answer_release_iter(iter);
answer_release(ans);
ans = kv_ask("lrange mylist 0 3", strlen("lrange mylist 0 3"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
iter = answer_get_iter(ans, ANSWER_HEAD);
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "c");
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "b");
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a");
value = answer_next(iter);
CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL);
answer_release_iter(iter);
answer_release(ans);
ans = kv_ask("lrange mylist 0 -1", strlen("lrange mylist 0 -1"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
iter = answer_get_iter(ans, ANSWER_HEAD);
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "c");
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "b");
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a");
value = answer_next(iter);
CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL);
answer_release_iter(iter);
answer_release(ans);
ans = kv_ask("lrange mylist -1 -1", strlen("lrange mylist -1 -1"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
iter = answer_get_iter(ans, ANSWER_HEAD);
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a");
value = answer_next(iter);
CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL);
answer_release_iter(iter);
answer_release(ans);
ans = kv_ask("lrange mylist -1 1", strlen("lrange mylist -1 1"));
CU_ASSERT_EQUAL(ans->errnum, ERR_OUT_OF_RANGE);
answer_release(ans);
ans = kv_ask("lrange mylist 1 -1", strlen("lrange mylist 1 -1"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
iter = answer_get_iter(ans, ANSWER_HEAD);
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "b");
value = answer_next(iter);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a");
value = answer_next(iter);
CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL);
answer_release_iter(iter);
answer_release(ans);
kv_uninit();
}
int main()
{
long long start, end, duration, t1, t2;
struct timeval tv;
int i, j, key_size, value_buffer_size;
kvs_env.init_type = INIT_TYPE_CREATE;
kvs_env.disk_file_path = "disk_file";
kvs_env.IMAGE_file_path = "IMAGE_file";
kvs_env.log_file_path = "log_file";
kvs_env.buffer_sleep_time = 0;
kvs_env.buffer_horizon_size = 100 * 1024 * 1024;
kvs_env.buffer_size = 700 * 1024 * 1024;
for (i = 0; i < VALUE_BUFFER_SIZE; i++)
value_buffer[i] = 'a';
srand((unsigned) time(NULL));
gettimeofday(&tv, NULL);
start = tv.tv_sec * 1000 * 1000 + tv.tv_usec;
if (kv_init(&kvs_env) != 0)
{
printf("kvs_init fail\n");
return -1;
}
//first write 5GB
for (i = 0; i < CNT; i++)
{
get_key(key_buffer, i, &key_size);
if (kv_put(key_buffer, key_size, value_buffer, VALUE_BUFFER_SIZE) != 0)
{
printf("kv_put fail\n");
return -1;
}
}
duration = 0;
j = CNT;
for (i = 0; i < CNT; i++)
{
get_key(key_buffer, j, &key_size);
if (i % 200 == 0)
{
if (kv_put(key_buffer, key_size, value_buffer, VALUE_BUFFER_SIZE) != 0)
{
printf("kv_put fail\n");
return -1;
}
j++;
}
random_key(key_buffer, j - 1, &key_size);
gettimeofday(&tv, NULL);
t1 = tv.tv_sec * 1000 * 1000 + tv.tv_usec;
if (kv_get(key_buffer, key_size, value_buffer, &value_buffer_size) != 0)
{
printf("kv_get fail\n");
return -1;
}
gettimeofday(&tv, NULL);
t2 = tv.tv_sec * 1000 * 1000 + tv.tv_usec;
duration += (t2 - t1) / 1000;
}
kv_exit();
printf("read time: %lld ms\n", duration);
gettimeofday(&tv, NULL);
end = tv.tv_sec * 1000 * 1000 + tv.tv_usec;
duration = (end - start) / 1000;
printf("total time: %lld ms\n", duration);
return 0;
}
static aln_v align_read(const kseq_t *read, const kseq_v targets,
const size_t n_extra_targets,
const kseq_v *extra_targets,
const align_config_t *conf) {
kseq_t *r;
const int32_t read_len = read->seq.l;
aln_v result;
kv_init(result);
kv_resize(aln_t, result, kv_size(targets));
uint8_t *read_num = calloc(read_len, sizeof(uint8_t));
for (int k = 0; k < read_len; ++k)
read_num[k] = conf->table[(int)read->seq.s[k]];
// Align to each target
kswq_t *qry = NULL;
int min_score = -1000;
int max_score = 0;
for (size_t j = 0; j < kv_size(targets); j++) {
// Encode target
r = &kv_A(targets, j);
aln_t aln =
align_read_against_one(r, read_len, read_num, &qry, conf, min_score);
if (aln.cigar != NULL) {
max_score = aln.loc.score > max_score ? aln.loc.score : max_score;
min_score = (aln.loc.score - conf->max_drop) > min_score
? (aln.loc.score - conf->max_drop)
: min_score;
kv_push(aln_t, result, aln);
}
}
/* If no alignments to the first set of targets reached the minimum score,
* abort.
*/
if (max_score < conf->min_score) {
// kv_size returns the n field of a kvec_t, which is a size_t.
for (size_t i = 0; i < kv_size(result); i++)
free(kv_A(result, i).cigar);
kv_size(result) = 0;
free(qry);
free(read_num);
return result;
}
drop_low_scores(&result, 0, conf->max_drop);
// Extra references - qe points to the exact end of the sequence
int qend = kv_A(result, 0).loc.qe + 1;
int read_len_trunc = read_len - qend;
uint8_t *read_num_trunc = read_num + qend;
free(qry);
qry = NULL;
if (read_len_trunc > 2) {
for (size_t i = 0; i < n_extra_targets; i++) {
const size_t idx = n_extra_targets - i - 1;
min_score = -1000;
const size_t init_count = kv_size(result);
for (size_t j = 0; j < kv_size(extra_targets[idx]); j++) {
r = &kv_A(extra_targets[idx], j);
aln_t aln = align_read_against_one(r, read_len_trunc, read_num_trunc,
&qry, conf, min_score);
if (aln.cigar != NULL) {
min_score = (aln.loc.score - conf->max_drop) > min_score
? (aln.loc.score - conf->max_drop)
: min_score;
aln.loc.qb += qend;
aln.loc.qe += qend;
kv_push(aln_t, result, aln);
}
}
drop_low_scores(&result, init_count, conf->max_drop);
/* Truncate */
const int alen =
kv_A(result, init_count).loc.qe - kv_A(result, init_count).loc.qb;
read_len_trunc = read_len_trunc - alen;
free(qry);
qry = NULL;
}
}
free(qry);
free(read_num);
return result;
}
mem_alnreg_v mem_fmeas_fliter_se(mem_alnreg_v a , int n , int l_seq , int mode)
{
mem_alnreg_v aa ;
int i , j ;
kvec_t(FF_t) k_ff_t ;
kv_init(k_ff_t);
kv_init(aa);
// caculate FMEAS value
if(n == 0) return aa ;
for( i = 0 ; i < a.n ; i++){
mem_alnreg_t *p_ar = a.a + i ;
for( j = i + 1 ; j < a.n ; j++){
FF_t tmp ;
mem_alnreg_t *q_ar = a.a + j ;
double sens , spec ;
int FN = 0 , TP = 0 ,TN = 0 , FP = 0 ;
int A,B,C,D;
if( p_ar->qb < q_ar->qb || (p_ar->qb == q_ar->qb && p_ar->qe >= q_ar->qe)){ // p q
A = p_ar->qb ;
B = p_ar->qe - 1 ;
C = q_ar->qb ;
D = q_ar->qe - 1 ;
}else { // p q
A = q_ar->qb ;
B = q_ar->qe - 1;
C = p_ar->qb ;
D = p_ar->qe - 1;
}
if(B < C){
TP = B - A + D - C + 2 ;
FN = l_seq - D - 1 + A + C - B - 1 ;
TN = l_seq ;
FP = 0 ;
}else if( D <= B){ // contain
continue ;
}else{
TP = D - A + 1 ;
FN = l_seq - D - 1 + A ;
FP = B - C + 1 ;
TN = l_seq - FP;
}
sens = (double)TP/(double)(TP+FN);
spec = (double)TN/(double)(TN+FP);
tmp.FMEAS = (2*spec*sens)/(spec+sens);
tmp.score = p_ar->score + q_ar->score;
tmp.x = i , tmp.y = j ;
if(tmp.FMEAS > 0.95) kv_push(FF_t,k_ff_t,tmp);
}
}
ks_introsort(ff_mem_flt, k_ff_t.n, k_ff_t.a);
kv_push(mem_alnreg_t,aa,a.a[0]);
double max_feas ;
// int score ;
if( k_ff_t.n == 0 ) return aa;
max_feas = k_ff_t.a[0].FMEAS ;
// score = k_ff_t.a[0].score ;
if(mode){
int cnt = 0 ;
for( i = 0 ; i < kv_size(k_ff_t) ; i++){
FF_t p = kv_A(k_ff_t,i);
if(p.x == 0 && cnt == 0){
kv_push(mem_alnreg_t,aa,a.a[p.y]);
cnt = 1 ;
}else if(p.x == 0){
kv_push(mem_alnreg_t,aa,a.a[0]);
kv_push(mem_alnreg_t,aa,a.a[p.y]);
}
}
for( i = 0 ; i < kv_size(k_ff_t); i++){
FF_t p = kv_A(k_ff_t,i);
if(max_feas != p.FMEAS ) break;
if(p.x == 0) continue ;
kv_push(mem_alnreg_t,aa,a.a[p.x]);
kv_push(mem_alnreg_t,aa,a.a[p.y]);
}
}else{
int cnt = 0 ;
for( i = 0 ; i < kv_size(k_ff_t); i++){
FF_t p = kv_A(k_ff_t,i);
if(max_feas != p.FMEAS ) break;
if(p.x == 0 && cnt == 0){
kv_push(mem_alnreg_t,aa,a.a[p.y]);
continue ;
}else if( p.x == 0 ){
kv_push(mem_alnreg_t,aa,a.a[0]);
kv_push(mem_alnreg_t,aa,a.a[p.y]);
continue ;
}
kv_push(mem_alnreg_t,aa,a.a[p.x]);
kv_push(mem_alnreg_t,aa,a.a[p.y]);
}
}
kv_destroy(k_ff_t);
#if 0
for( i = 0 ; i < kv_size(aa); i++){
mem_alnreg_t *q = aa.a + i;
printf("%db: %d %de:%d \t" , i, q->qb , i, q->qe);
if( i == kv_size(aa) -1 ) printf("\n");
}
#endif
return aa ;
}
int main(int argc, char *argv[])
{
//initialize Key-Value store--------------------------------------------------
kv_t **vhost_ptr = (kv_t**)get_env(argv, US_VHOST_DATA), //persistent ptr
*forum_store = 0; //convenience pointer (var->m instead of (*var)->m)
if (vhost_ptr && !*vhost_ptr)
{
*vhost_ptr = (kv_t*)malloc(sizeof(kv_t));
//threads and posts stored here
kv_init(*vhost_ptr, "forum_store", 1024, 0, 0, 0);
} forum_store = *vhost_ptr;
//----------------------------------------------------------------------------
//setup GET and POST variables------------------------------------------------
char *act = "", *id = "", *title = "", *body = "";
get_arg("act=", &act, argc, argv); //action ('t' or 'p')
get_arg("id=", &id, argc, argv); //id of thread
get_arg("title=", &title, argc, argv); //title of thread
get_arg("body=", &body, argc, argv); //body of post
char *end = 0;
u64 int_id = strtoll(id, &end, 10); //string to integer
if (*end) int_id = 0; //require a numeric ID
//----------------------------------------------------------------------------
//response sent to browser is stored here-------------------------------------
//templates are rendered into this buffer
xbuf_t *reply = get_reply(argv);
xbuf_cat(reply, base_tpl); //set base template
//----------------------------------------------------------------------------
//HTTP state of a connection
http_t *http = (http_t*)get_env(argv, HTTP_HEADERS);
redirect: //simulate HTTP, <meta>, or JavaScript redirect without page reload
//choose what to do based on the value of 'act'-------------------------------
switch (*act)
{
//regarding a post
case 'p':
{
switch (http->h_method) //GET or POST
{
//new post--------------------------------------------------------------
case HTTP_POST:
{
//get the thread to which this post belongs
Thread *thread = (Thread*)kv_get(forum_store, (char*)&int_id, sizeof(int_id));
if (!thread) //thread not found
{
xbuf_repl(reply, "<!--tpl-->", http_error(404));
return 404;
}
//allocate memory
Post *post = calloc(1, sizeof(*post));
//initialize members
xbuf_init(&post->body);
//define members
post->id = thread->posts.nbr_items + 1;
xbuf_cat(&post->body, *body ? body : " ");
//add post to thread
kv_add(&thread->posts, &(kv_item) {
.key = (char*)&post->id,
.klen = sizeof(post->id),
.val = (char*)post,
.flags = 0,
});
//setup redirect
http->h_method = HTTP_GET;
*act = 't';
goto redirect;
} break;
//----------------------------------------------------------------------
}
} break;
//regarding a thread
case 't':
{
switch (http->h_method)
{
//view a thread---------------------------------------------------------
case HTTP_GET:
{
Thread *thread = (Thread*)kv_get(forum_store, (char*)&int_id, sizeof(int_id));
if (!thread)
{
xbuf_repl(reply, "<!--tpl-->", http_error(404));
return 404;
}
//replace template variables with dynamic values
xbuf_repl(reply, "<!--form-->", post_form);
xbuf_repl(reply, "<!--title-->", thread->title.ptr);
xbuf_repl(reply, "<!--id-->", id);
//for each post, render its template and insert it into reply
kv_do(&thread->posts, 0, 0, (kv_proc_t)&list_posts, (void*)reply);
} break;
//----------------------------------------------------------------------
//create a thread-------------------------------------------------------
case HTTP_POST:
{
Thread *thread = calloc(1, sizeof(*thread));
xbuf_init(&thread->title);
kv_init(&thread->posts, "posts", 1024, 0, 0, 0);
thread->id = forum_store->nbr_items + 1;
xbuf_cat(&thread->title, *title ? title : " ");
//add thread to KV store
kv_add(forum_store, &(kv_item) {
.key = (char*)&thread->id,
.klen = sizeof(thread->id),
.val = (char*)thread,
.flags = 0,
});
http->h_method = HTTP_GET;
*act = 0;
goto redirect;
} break;
//----------------------------------------------------------------------
}
} break;
void case_cmd_incrby()
{
/**
* incr valid number to no_exist key
* incr valid number to exist key(string-type)
* incr valid number to exist key(lpush-type)
* incr invalid number to no_exist key
* incr invalid number to exist key(string-type)
* incr invalid number to exist key(lpush-type)
*/
answer_t *ans;
CU_ASSERT_EQUAL(kv_init(NULL), ERR_NONE);
ans = kv_ask("flushdb", strlen("flushdb"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
/** no exist key */
ans = kv_ask("incrby no_exist_key 123", strlen("incrby no_exist_key 123"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "123");
answer_release(ans);
ans = kv_ask("get no_exist_key", strlen("get no_exist_key"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "123");
answer_release(ans);
/** exist key */
ans = kv_ask("set key 123", strlen("set key 123"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("incrby key 123", strlen("incrby key 123"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "246");
answer_release(ans);
ans = kv_ask("get key", strlen("get key"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "246");
answer_release(ans);
/** list */
ans = kv_ask("lpush lkey a b c", strlen("lpush lkey a b c"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "3");
answer_release(ans);
ans = kv_ask("incrby lkey 456", strlen("incr lkey 456"));
CU_ASSERT_EQUAL(ans->errnum, ERR_TYPE);
answer_release(ans);
ans = kv_ask("flushdb", strlen("flushdb"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
/**
* incrby invalid number
*/
/** no exist key */
ans = kv_ask("incrby no_exist_key abcd", strlen("incrby no_exist_key abcd"));
CU_ASSERT_EQUAL(ans->errnum, ERR_VALUE);
answer_release(ans);
/** exist key */
ans = kv_ask("set key 123", strlen("set key 123"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("incrby key abcd", strlen("incr key abcd"));
CU_ASSERT_EQUAL(ans->errnum, ERR_VALUE);
answer_release(ans);
ans = kv_ask("get key", strlen("get key"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "123");
answer_release(ans);
/** invalid value */
ans = kv_ask("set key1 abcd", strlen("set key1 abcd"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("incrby key1 123", strlen("incrby key1 123"));
CU_ASSERT_EQUAL(ans->errnum, ERR_VALUE);
answer_release(ans);
/** list */
ans = kv_ask("lpush lkey a b c", strlen("lpush lkey a b c"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "3");
answer_release(ans);
ans = kv_ask("incrby lkey 456", strlen("incr lkey 456"));
CU_ASSERT_EQUAL(ans->errnum, ERR_TYPE);
answer_release(ans);
ans = kv_ask("flushdb", strlen("flushdb"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
}
void case_cmd_flushdb()
{
/*
* flush empty db
* flush one key db
* flush 5000 string keys and 5000 lpush keys
*/
answer_t *ans;
static char buf[10000+128];
int i;
CU_ASSERT_EQUAL(kv_init(NULL), ERR_NONE);
ans = kv_ask("flushdb", strlen("flushdb"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("dbsize", strlen("dbsize"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0");
answer_release(ans);
ans = kv_ask("flushdb", strlen("flushdb"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("dbsize", strlen("dbsize"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0");
answer_release(ans);
/* flush one key */
ans = kv_ask("set key value", strlen("set key value"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("flushdb", strlen("flushdb"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("dbsize", strlen("dbsize"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0");
answer_release(ans);
/* flush list key */
ans = kv_ask("lpush lkey a b c", strlen("lpush lkey a b c"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "3");
answer_release(ans);
ans = kv_ask("flushdb", strlen("flushdb"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("dbsize", strlen("dbsize"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0");
answer_release(ans);
/* 5000 string keys and 5000 list keys */
for (i = 1; i <= 5000; i++) {
int bytes = snprintf(buf, sizeof(buf), "set key%d %d", i, i);
ans = kv_ask(buf, bytes);
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
bytes = snprintf(buf, sizeof(buf), "lpush lkey%d %d", i, i);
ans = kv_ask(buf, bytes);
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "1");
answer_release(ans);
}
ans = kv_ask("dbsize", strlen("dbsize"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "10000");
answer_release(ans);
ans = kv_ask("flushdb", strlen("flushdb"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK");
answer_release(ans);
ans = kv_ask("dbsize", strlen("dbsize"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0");
answer_release(ans);
}
countries_v
shape_load_countries(const char* filename) {
countries_v countries;
kv_init(countries);
double adfMinBound[4],
adfMaxBound[4];
// Read file
SHPHandle hSHP = SHPOpen( filename, "rb" );
if(hSHP == NULL) goto end_loading;
// Print shape bounds
int country_count, shapes_vype;
SHPGetInfo( hSHP, &country_count, &shapes_vype, adfMinBound, adfMaxBound );
fprintf(stderr, "Load %d countries\n", country_count);
// Iterate through countries
for(int i = 0; i < country_count; i++ ) {
SHPObject *shp = SHPReadObject(hSHP, i);
if(shp == NULL) goto end_loading;
if(shp->nParts == 0) continue;
// first part starts at point 0
if(shp->panPartStart[0] != 0) goto end_loading;
// collect parts of country
shapes_v shapes;
kv_init(shapes);
shapes.min = (point_t){shp->dfXMin, shp->dfYMin};
shapes.max = (point_t){shp->dfXMax, shp->dfYMax};
uint32_t parts = shp->nParts;
double k = 0.0;
for (uint32_t j=0; j<parts; j++) {
// start index
uint32_t s = shp->panPartStart[j];
// end index - start of next minus one, or end
uint32_t e = (j+1 < parts) ?
shp->panPartStart[j+1]:
shp->nVertices;
shape_v shape;
kv_init(shape);
// collect points of part
for(uint32_t i=s; i<e; i++){
point_t p = (point_t){shp->padfX[i], shp->padfY[i]};
kv_push(point_t, shape, p);
// cumulitive average for center
if(k>=1.0) {
shapes.center.x = (k-1.0)/k*shapes.center.x + p.x/k;
shapes.center.y = (k-1.0)/k*shapes.center.y + p.y/k;
}else {
shapes.center.x = p.x;
shapes.center.y = p.y;
}
k+=1.0;
}
kv_push(shape_v, shapes, shape);
}
SHPDestroyObject( shp );
kv_push(shapes_v, countries, shapes);
}
SHPClose( hSHP );
end_loading:
return countries;
}
void case_cmd_expireat_get()
{
answer_t *ans;
char cmd[128];
CU_ASSERT_EQUAL(kv_init(NULL), ERR_NONE);
ans = kv_ask("flushdb", strlen("flushdb"));
answer_release(ans);
ans = kv_ask("set key value", strlen("set key value"));
answer_release(ans);
int write = snprintf(cmd, sizeof(cmd), "expireat key %ld", time(NULL) + 5);
ans = kv_ask(cmd, strlen(cmd));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "1");
answer_release(ans);
sleep(3);
ans = kv_ask("get key", strlen("get key"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "value");
answer_release(ans);
sleep(3);
ans = kv_ask("get key", strlen("get key"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NIL);
CU_ASSERT_PTR_EQUAL(answer_value_to_string(answer_first_value(ans)), NULL);
answer_release(ans);
ans = kv_ask("dbsize", strlen("dbsize"));
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0");
answer_release(ans);
ans = kv_ask("set key value", strlen("set key value"));
answer_release(ans);
snprintf(cmd, sizeof(cmd), "expireat key %ld", time(NULL) + 2);
ans = kv_ask(cmd, strlen(cmd));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "1");
answer_release(ans);
sleep(3);
ans = kv_ask("del key", strlen("del key"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0");
answer_release(ans);
answer_release(kv_ask("set key value", strlen("set key value")));
ans = kv_ask("del key", strlen("del key"));
CU_ASSERT_EQUAL(ans->errnum, ERR_NONE);
CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "1");
answer_release(ans);
kv_uninit();
CU_ASSERT_EQUAL(kv_get_used_memory(), 0);
}
int main()
{
int i, state;
freopen("input_file", "r", stdin);
scanf("%d", &num);
for (i = 0; i < num; i++)
{
scanf("%d %s %d %s", &in[i].key_size, in[i].key, &in[i].value_size, in[i].value);
out[i].value_size = 1025;
}
//----------------KV_INIT-------------
fill_kvs_env();
if (kv_init(&kvs_env) != 0)
{
printf("kvs_init fail\n");
return -1;
}
//----------------KV_PUT-------------
for (i = 0; i < num / 2; i++)
{
state = kv_put(in[i].key, in[i].key_size, in[i].value, in[i].value_size);
if (state != 0)
{
printf("kv_put %d fail\n", i);
}
else
{
printf("put: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, in[i].value_size, in[i].value);
}
}
fflush(stdout);
//----------------KV_GET-------------
for (i = 0; i < num / 2; i++)
{
state = kv_get(in[i].key, in[i].key_size, out[i].value, &out[i].value_size);
if (state != 0)
{
printf("kv_get %d fail\n", i);
}
else
{
printf("get: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, out[i].value_size, out[i].value);
}
}
fflush(stdout);
//----------------KV_DELETE-------------
for (i = 0; i < num / 4; i += 2)
{
state = kv_delete(in[i].key, in[i].key_size);
if (state != 0)
{
printf("kv_delete %d fail\n", i);
}
else
{
printf("delete: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, out[i].value_size, out[i].value);
}
}
fflush(stdout);
//----------------KV_GET-------------
for (i = 0; i < num / 4; i += 2)
{
state = kv_get(in[i].key, in[i].key_size, out[i].value, &out[i].value_size);
if (state != 0)
{
printf("kv_get %d fail\n", i);
}
else
{
printf("get: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, out[i].value_size, out[i].value);
}
}
fflush(stdout);
//----------------KV_PUT-------------
for (i = num / 2; i < num; i++)
{
state = kv_put(in[i].key, in[i].key_size, in[i].value, in[i].value_size);
if (state != 0)
{
printf("kv_put %d fail\n", i);
}
else
{
printf("put: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, in[i].value_size, in[i].value);
}
}
fflush(stdout);
//----------------KV_GET-------------
for (i = num / 2; i < num; i++)
{
state = kv_get(in[i].key, in[i].key_size, out[i].value, &out[i].value_size);
if (state != 0)
{
printf("kv_get %d fail\n", i);
}
else
{
printf("get: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, out[i].value_size, out[i].value);
}
}
fflush(stdout);
//----------------KV_EXIT-------------
if (kv_exit(1) != 0)
{
printf("kvs_exit fail\n");
return -1;
}
return 0;
}
OBJ TrArray_new(VM) {
TrArray *a = TR_INIT_CORE_OBJECT(Array);
kv_init(a->kv);
return (OBJ)a;
}
