Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.operator.aggregation;
 
 
 import static com.facebook.presto.type.TypeUtils.hashPosition;
 import static com.facebook.presto.type.TypeUtils.positionEqualsPosition;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static io.airlift.units.DataSize.Unit.MEGABYTE;
 import static it.unimi.dsi.fastutil.HashCommon.arraySize;
 
 public class SimpleTypedSet
         implements TypedSet
 {
     private static final float FILL_RATIO = 0.75f;
     private static final long FOUR_MEGABYTES = new DataSize(4, ).toBytes();
 
     private final Type elementType;
     private final IntBigArray blockPositionByHash = new IntBigArray();
     private final BlockBuilder elementBlock;
 
     private int maxFill;
     private int hashMask;
     private static final int EMPTY_SLOT = -1;
 
     private boolean containsNullElement;
 
     public SimpleTypedSet(Type elementTypeint expectedSize)
     {
         checkArgument(expectedSize > 0, "expectedSize must be > 0");
         this. = checkNotNull(elementType"elementType must not be null");
         this. = elementType.createBlockBuilder(new BlockBuilderStatus(), expectedSize);
 
         int hashSize = arraySize(expectedSize);
         this. = calculateMaxFill(hashSize);
         this. = hashSize - 1;
 
         .ensureCapacity(hashSize);
         for (int i = 0; i < hashSizei++) {
             .set(i);
         }
 
         this. = false;
     }
 
     @Override
     public long getEstimatedSize()
     {
         return .getSizeInBytes() + .sizeOf();
     }
 
     @Override
     public boolean contains(Block blockint position)
     {
         checkNotNull(block"block must not be null");
         checkArgument(position >= 0, "position must be >= 0");
 
         if (block.isNull(position)) {
             return ;
         }
         else {
             return .get(getHashPositionOfElement(blockposition)) != ;
         }
     }
 
     @Override
     public void add(Block blockint position)
     {
         checkNotNull(block"block must not be null");
         checkArgument(position >= 0, "position must be >= 0");
 
         if (block.isNull(position)) {
              = true;
         }
         else {
             int hashPosition = getHashPositionOfElement(blockposition);
             if (.get(hashPosition) == ) {
                 addNewElement(hashPositionblockposition);
             }
         }
    }
    @Override
    public int size()
    {
        return .getPositionCount() + ( ? 1 : 0);
    }

    
Get slot position of element at position of block
    private int getHashPositionOfElement(Block blockint position)
    {
        int hashPosition = getMaskedHash(hashPosition(blockposition));
        while (true) {
            int blockPosition = .get(hashPosition);
            // Doesn't have this element
            if (blockPosition == ) {
                return hashPosition;
            }
            // Already has this element
            else if (positionEqualsPosition(blockPositionblockposition)) {
                return hashPosition;
            }
            hashPosition = getMaskedHash(hashPosition + 1);
        }
    }
    private void addNewElement(int hashPositionBlock blockint position)
    {
        .appendTo(blockposition);
        if (.getSizeInBytes() > ) {
            throw new ExceededMemoryLimitException(new DataSize(4, ));
        }
        .set(hashPosition.getPositionCount() - 1);
        // increase capacity, if necessary
        if (.getPositionCount() >= ) {
            rehash( * 2);
        }
    }
    private void rehash(int size)
    {
        int newHashSize = arraySize(size + 1, );
         = newHashSize - 1;
         = calculateMaxFill(newHashSize);
        .ensureCapacity(newHashSize);
        for (int i = 0; i < newHashSizei++) {
            .set(i);
        }
        rehashBlock();
    }
    private void rehashBlock(Block block)
    {
        for (int blockPosition = 0; blockPosition < block.getPositionCount(); blockPosition++) {
            .set(getHashPositionOfElement(blockblockPosition), blockPosition);
        }
    }
    private static int calculateMaxFill(int hashSize)
    {
        int maxFill = (int) Math.ceil(hashSize * );
        if (maxFill == hashSize) {
            maxFill--;
        }
        return maxFill;
    }
    private int getMaskedHash(int rawHash)
    {
        return rawHash & ;
    }
New to GrepCode? Check out our FAQ X