8 #include "../misc/utils.h"
16 handleOne(RLEEncoder& encoder, pair_type& run, usint position)
24 if(position == run.first + run.second)
29 encoder.setRun(run.first, run.second);
35 handleRun(RLEEncoder& encoder, pair_type& run, pair_type& next, usint limit)
39 run.first = next.first;
40 run.second = std::min(limit - run.first, next.second);
41 next.first += run.second;
42 next.second -= run.second;
46 if(next.first == run.first + run.second)
48 usint cont = std::min(limit - next.first, next.second);
55 encoder.setRun(run.first, run.second);
56 run.first = next.first;
57 run.second = std::min(limit - run.first, next.second);;
58 next.first += run.second;
59 next.second -= run.second;
63 mergeVectors(RLEVector* first, RLEVector* second, usint* positions, usint n, usint size, usint block_size)
65 if((first == 0 && second == 0) || positions == 0) { return 0; }
67 RLEVector::Iterator* first_iter = 0;
68 RLEVector::Iterator* second_iter = 0;
74 first_run = pair_type(size, 0);
75 first_finished = true;
79 first_iter = new RLEVector::Iterator(*first);
80 first_run = first_iter->selectRun(0, size);
82 first_finished = false;
92 second_iter = new RLEVector::Iterator(*second);
93 second_bit = second_iter->select(0);
96 RLEEncoder encoder(block_size);
97 pair_type run = pair_type(size, 0);
98 for(usint i = 0; i < n; i++, first_run.first++)
100 while(!first_finished && first_run.first < positions[i])
102 handleRun(encoder, run, first_run, positions[i]);
103 if(first_run.second == 0)
105 if(first_iter->hasNext())
107 first_run = first_iter->selectNextRun(size);
108 first_run.first += i;
113 first_finished = true;
118 if(i == second_bit) // positions[i] is one
120 handleOne(encoder, run, positions[i]);
121 second_bit = second_iter->selectNext();
123 else // positions[i] is zero
127 encoder.setRun(run.first, run.second);
133 while(!first_finished)
135 handleRun(encoder, run, first_run, size);
136 if(first_iter->hasNext())
138 first_run = first_iter->selectNextRun(size);
139 first_run.first += n;
147 encoder.setRun(run.first, run.second);
150 delete first_iter; delete second_iter;
151 delete first; delete second;
152 return new RLEVector(encoder, size);
155 //--------------------------------------------------------------------------
158 mergeVectors(DeltaVector* first, DeltaVector* second, usint* positions, usint n, usint size, usint block_size)
160 if((first == 0 && second == 0) || positions == 0) { return 0; }
162 DeltaVector::Iterator* first_iter = 0;
163 DeltaVector::Iterator* second_iter = 0;
170 first_finished = true;
174 first_iter = new DeltaVector::Iterator(*first);
175 first_bit = first_iter->select(0);
176 first_finished = false;
186 second_iter = new DeltaVector::Iterator(*second);
187 second_bit = second_iter->select(0);
190 DeltaEncoder encoder(block_size);
191 for(usint i = 0; i < n; i++, first_bit++)
193 while(!first_finished && first_bit < positions[i])
195 encoder.setBit(first_bit);
196 if(first_iter->hasNext())
198 first_bit = first_iter->selectNext() + i;
202 first_finished = true;
206 if(i == second_bit) // positions[i] is one
208 encoder.setBit(positions[i]);
209 second_bit = second_iter->selectNext();
213 while(!first_finished)
215 encoder.setBit(first_bit);
216 if(!first_iter->hasNext()) { break; }
217 first_bit = first_iter->selectNext() + n;
220 delete first_iter; delete second_iter;
221 delete first; delete second;
222 return new DeltaVector(encoder, size);