Ejemplo n.º 1
0
 /**
  * Implementation of {@link #build()} and {@link #finish()}.
  *
  * @param reuse Whether we should try to reuse the builder's storage for the packed list. If
  *     {@code true}, the builder will be invalid after finishing and the packed list will use the
  *     same arrays as the builder if they are full.
  * @return The packed ID list.
  */
 private PackedScoredIdList finish(boolean reuse) {
   Preconditions.checkState(ids != null, "builder has been finished");
   Map<Symbol, DoubleList> chans;
   Map<TypedSymbol<?>, List<?>> typedChans;
   if (size() > 0) {
     ImmutableMap.Builder<Symbol, DoubleList> cbld = ImmutableMap.builder();
     for (ChannelStorage chan : channels.values()) {
       DoubleArrayList built;
       if (reuse) {
         built = chan.values;
         built.trim();
       } else {
         built = new DoubleArrayList(chan.values);
       }
       cbld.put(chan.symbol, built);
     }
     chans = cbld.build();
     ImmutableMap.Builder<TypedSymbol<?>, List<?>> tcbld = ImmutableMap.builder();
     for (TypedChannelStorage<?> chan : typedChannels.values()) {
       List<?> built;
       if (reuse) {
         chan.values.trimToSize();
         built = chan.values;
       } else {
         built = new ArrayList<Object>(chan.values);
       }
       tcbld.put(chan.symbol, built);
     }
     typedChans = tcbld.build();
   } else {
     chans = Collections.emptyMap();
     typedChans = Collections.emptyMap();
   }
   LongList builtIds;
   DoubleList builtScores;
   if (reuse) {
     ids.trim();
     builtIds = ids;
     scores.trim();
     builtScores = scores;
     clear();
   } else {
     builtIds = new CompactableLongArrayList(ids);
     builtScores = new DoubleArrayList(scores);
   }
   return new PackedScoredIdList(builtIds, builtScores, typedChans, chans);
 }
Ejemplo n.º 2
0
 @Override
 public void seal() {
   ((DoubleArrayList) _innerList).trim();
   _elements = ((DoubleArrayList) _innerList).elements();
   int negativeIndexCheck = 1;
   // reverse negative elements, because string order and numeric orders are completely opposite
   if (_elements.length > negativeIndexCheck && _elements[negativeIndexCheck] < 0) {
     int endPosition = indexOfWithType((short) 0);
     if (endPosition < 0) {
       endPosition = -1 * endPosition - 1;
     }
     double tmp;
     for (int i = 0; i < (endPosition - negativeIndexCheck) / 2; i++) {
       tmp = _elements[i + negativeIndexCheck];
       _elements[i + negativeIndexCheck] = _elements[endPosition - i - 1];
       _elements[endPosition - i - 1] = tmp;
     }
   }
 }