{
if((first == 0 && second == 0) || positions == 0) { return 0; }
+ RLEVector::Iterator* first_iter = 0;
+ RLEVector::Iterator* second_iter = 0;
+
pair_type first_run;
bool first_finished;
if(first == 0)
}
else
{
- first_run = first->selectRun(0, size);
+ first_iter = new RLEVector::Iterator(*first);
+ first_run = first_iter->selectRun(0, size);
first_run.second++;
first_finished = false;
}
}
else
{
- second_bit = second->select(0);
+ second_iter = new RLEVector::Iterator(*second);
+ second_bit = second_iter->select(0);
}
RLEEncoder encoder(block_size);
handleRun(encoder, run, first_run, positions[i]);
if(first_run.second == 0)
{
- if(first->hasNext())
+ if(first_iter->hasNext())
{
- first_run = first->selectNextRun(size);
+ first_run = first_iter->selectNextRun(size);
first_run.first += i;
first_run.second++;
}
if(i == second_bit) // positions[i] is one
{
handleOne(encoder, run, positions[i]);
- second_bit = second->selectNext();
+ second_bit = second_iter->selectNext();
}
else // positions[i] is zero
{
while(!first_finished)
{
handleRun(encoder, run, first_run, size);
- if(first->hasNext())
+ if(first_iter->hasNext())
{
- first_run = first->selectNextRun(size);
+ first_run = first_iter->selectNextRun(size);
first_run.first += n;
first_run.second++;
}
encoder.setRun(run.first, run.second);
}
+ delete first_iter; delete second_iter;
delete first; delete second;
return new RLEVector(encoder, size);
}
{
if((first == 0 && second == 0) || positions == 0) { return 0; }
+ DeltaVector::Iterator* first_iter = 0;
+ DeltaVector::Iterator* second_iter = 0;
+
usint first_bit;
bool first_finished;
if(first == 0)
}
else
{
- first_bit = first->select(0);
+ first_iter = new DeltaVector::Iterator(*first);
+ first_bit = first_iter->select(0);
first_finished = false;
}
}
else
{
- second_bit = second->select(0);
+ second_iter = new DeltaVector::Iterator(*second);
+ second_bit = second_iter->select(0);
}
DeltaEncoder encoder(block_size);
while(!first_finished && first_bit < positions[i])
{
encoder.setBit(first_bit);
- if(first->hasNext())
+ if(first_iter->hasNext())
{
- first_bit = first->selectNext() + i;
+ first_bit = first_iter->selectNext() + i;
}
else
{
if(i == second_bit) // positions[i] is one
{
encoder.setBit(positions[i]);
- second_bit = second->selectNext();
+ second_bit = second_iter->selectNext();
}
}
while(!first_finished)
{
encoder.setBit(first_bit);
- if(!first->hasNext()) { break; }
- first_bit = first->selectNext() + n;
+ if(!first_iter->hasNext()) { break; }
+ first_bit = first_iter->selectNext() + n;
}
+ delete first_iter; delete second_iter;
delete first; delete second;
return new DeltaVector(encoder, size);
}