libcds/src/static_sequence/static_sequence_bs.cpp

   1
   2 #include <static_sequence_bs.h>
   3
   4 static_sequence_bs::static_sequence_bs(uint * seq, uint n, alphabet_mapper * am, static_bitsequence_builder * bmb) {
   5         sigma = 0;
   6         len = n;
   7         this->am = am;
   8         am->use();
   9         for(uint i=0;i<n;i++) sigma=max(sigma,am->map(seq[i]));
  10         bitmaps = new static_bitsequence*[++sigma];
  11         uint ** bm = new uint*[sigma];
  12         for(uint i=0;i<sigma;i++) {
  13                 bm[i] = new uint[uint_len(len,1)];
  14                 for(uint j=0;j<uint_len(len,1);j++)
  15                         bm[i][j] = 0;
  16         }
  17         for(uint i=0;i<n;i++)
  18                 bitset(bm[am->map(seq[i])],i);
  19         for(uint i=0;i<sigma;i++)
  20                 bitmaps[i] = bmb->build(bm[i],len);
  21         for(uint i=0;i<sigma;i++)
  22                 delete [] bm[i];
  23         delete [] bm;
  24 }
  25
  26 static_sequence_bs::static_sequence_bs() {
  27         len = 0;
  28         sigma = 0;
  29         bitmaps = NULL;
  30         am = NULL;
  31 }
  32
  33 static_sequence_bs::~static_sequence_bs() {
  34         if(bitmaps!=NULL) {
  35                 for(uint i=0;i<sigma;i++) {
  36                         if(bitmaps[i]!=NULL) delete bitmaps[i];
  37                 }
  38                 delete [] bitmaps;
  39         }
  40         if(am!=NULL) am->unuse();
  41 }
  42
  43 uint static_sequence_bs::rank(uint c, uint i) {
  44         if(am->map(c)>=sigma) return (uint)-1;
  45         return bitmaps[am->map(c)]->rank1(i);
  46 }
  47
  48 uint static_sequence_bs::select(uint c, uint i) {
  49         if(am->map(c)>=sigma) return (uint)-1;
  50         return bitmaps[am->map(c)]->select1(i);
  51 }
  52
  53 uint static_sequence_bs::select_next(uint c, uint i) {
  54         if(am->map(c)>=sigma) return (uint)-1;
  55         return bitmaps[am->map(c)]->select_next1(i);
  56 }
  57
  58 uint static_sequence_bs::access(uint i) {
  59         for(uint j=0;j<sigma;j++) {
  60                 if(bitmaps[j]->access(i)) return am->unmap(j);
  61         }
  62         return (uint)-1;
  63 }
  64
  65 uint static_sequence_bs::size() {
  66         uint size = sizeof(static_sequence_bs)+am->size();
  67         for(uint i=0;i<sigma;i++)
  68                 size += bitmaps[i]->size();
  69         return size;
  70 }
  71
  72 uint static_sequence_bs::save(FILE * fp) {
  73         uint wr = BS_HDR;
  74         wr = fwrite(&wr,sizeof(uint),1,fp);
  75         wr += fwrite(&len,sizeof(uint),1,fp);
  76         wr += fwrite(&sigma,sizeof(uint),1,fp);
  77         if(wr!=3) return 1;
  78         for(uint i=0;i<sigma;i++)
  79                 if(bitmaps[i]->save(fp)) return 2;
  80         if(am->save(fp)) return 3;
  81         return 0;
  82 }
  83
  84 static_sequence_bs * static_sequence_bs::load(FILE * fp) {
  85         uint rd = 0;
  86         uint type = 0;
  87         rd += fread(&type,sizeof(uint),1,fp);
  88         static_sequence_bs * ret = new static_sequence_bs();
  89         rd += fread(&ret->len,sizeof(uint),1,fp);
  90         rd += fread(&ret->sigma,sizeof(uint),1,fp);
  91         if(rd!=3 || type != BS_HDR) {
  92                 delete ret;
  93                 return NULL;
  94         }
  95         ret->bitmaps = new static_bitsequence*[ret->sigma];
  96         for(uint i=0;i<ret->sigma;i++)
  97                 ret->bitmaps[i] = NULL;
  98         for(uint i=0;i<ret->sigma;i++)
  99                 if((ret->bitmaps[i]=static_bitsequence::load(fp))==NULL) {
 100                         delete ret;
 101                         return NULL;
 102                 }
 103         if((ret->am = alphabet_mapper::load(fp))==NULL) {
 104                 delete ret;
 105                 return NULL;
 106         }
 107         ret->am->use();
 108         return ret;
 109 }
 110