com.google.common.collect.ImmutableMapEntry.NonTerminalImmutableBiMapEntry的实例源码

项目：guava-mock    文件：RegularImmutableBiMap.java   

static <K,V> RegularImmutableBiMap<K,V> fromEntryArray(int n,Entry<K,V>[] entryArray) {
  checkPositionIndex(n,entryArray.length);
  int tableSize = Hashing.closedTableSize(n,MAX_LOAD_FACTOR);
  int mask = tableSize - 1;
  ImmutableMapEntry<K,V>[] keyTable = createEntryArray(tableSize);
  ImmutableMapEntry<K,V>[] valueTable = createEntryArray(tableSize);
  Entry<K,V>[] entries;
  if (n == entryArray.length) {
    entries = entryArray;
  } else {
    entries = createEntryArray(n);
  }
  int hashCode = 0;

  for (int i = 0; i < n; i++) {
    @SuppressWarnings("unchecked")
    Entry<K,V> entry = entryArray[i];
    K key = entry.getKey();
    V value = entry.getValue();
    checkEntryNotNull(key,value);
    int keyHash = key.hashCode();
    int valueHash = value.hashCode();
    int keyBucket = Hashing.smear(keyHash) & mask;
    int valueBucket = Hashing.smear(valueHash) & mask;

    ImmutableMapEntry<K,V> nextInKeyBucket = keyTable[keyBucket];
    checkNoConflictInKeyBucket(key,entry,nextInKeyBucket);
    ImmutableMapEntry<K,V> nextInValueBucket = valueTable[valueBucket];
    checkNoConflictInValueBucket(value,nextInValueBucket);
    ImmutableMapEntry<K,V> newEntry;
    if (nextInValueBucket == null && nextInKeyBucket == null) {
      /*
       * Todo(lowasser): consider using a NonTerminalImmutableMapEntry when nextInKeyBucket is
       * nonnull but nextInValueBucket is null.  This may save a few bytes on some platforms,but
       * 2-morphic call sites are often optimized much better than 3-morphic,so it'd require
       * benchmarking.
       */
      boolean reusable =
          entry instanceof ImmutableMapEntry && ((ImmutableMapEntry<K,V>) entry).isReusable();
      newEntry =
          reusable ? (ImmutableMapEntry<K,V>) entry : new ImmutableMapEntry<K,V>(key,value);
    } else {
      newEntry =
          new NonTerminalImmutableBiMapEntry<K,V>(
              key,value,nextInKeyBucket,nextInValueBucket);
    }
    keyTable[keyBucket] = newEntry;
    valueTable[valueBucket] = newEntry;
    entries[i] = newEntry;
    hashCode += keyHash ^ valueHash;
  }
  return new RegularImmutableBiMap<K,V>(keyTable,valueTable,entries,mask,hashCode);
}

项目：googles-monorepo-demo    文件：RegularImmutableBiMap.java   

static <K,hashCode);
}

项目：codebuff    文件：RegularImmutableBiMap.java   

static <K,V>[] entryArray) {
    checkPositionIndex(n,entryArray.length);
    int tableSize = Hashing.closedTableSize(n,MAX_LOAD_FACTOR);
    int mask = tableSize - 1;
    ImmutableMapEntry<K,V>[] keyTable = createEntryArray(tableSize);
    ImmutableMapEntry<K,V>[] valueTable = createEntryArray(tableSize);
    Entry<K,V>[] entries;
    if (n == entryArray.length) {
      entries = entryArray;
    } else {
      entries = createEntryArray(n);
    }
    int hashCode = 0;
    for (int i = 0; i < n; i++) {
      @SuppressWarnings("unchecked")
      Entry<K,V> entry = entryArray[i];
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key,value);
      int keyHash = key.hashCode();
      int valueHash = value.hashCode();
      int keyBucket = Hashing.smear(keyHash) & mask;
      int valueBucket = Hashing.smear(valueHash) & mask;
      ImmutableMapEntry<K,V> nextInKeyBucket = keyTable[keyBucket];
      checkNoConflictInKeyBucket(key,nextInKeyBucket);
      ImmutableMapEntry<K,V> nextInValueBucket = valueTable[valueBucket];
      checkNoConflictInValueBucket(value,nextInValueBucket);
      ImmutableMapEntry<K,V> newEntry;
      if (nextInValueBucket == null && nextInKeyBucket == null) {
        /*
         * Todo(lowasser): consider using a NonTerminalImmutableMapEntry when nextInKeyBucket is
         * nonnull but nextInValueBucket is null.  This may save a few bytes on some platforms,but
         * 2-morphic call sites are often optimized much better than 3-morphic,so it'd require
         * benchmarking.
         */
        boolean reusable =
          entry instanceof ImmutableMapEntry
&& ((ImmutableMapEntry<K,V>) entry).isReusable();
        newEntry = reusable ? (ImmutableMapEntry<K,value);
      } else {
        newEntry = new NonTerminalImmutableBiMapEntry<K,nextInValueBucket);
      }
      keyTable[keyBucket] = newEntry;
      valueTable[valueBucket] = newEntry;
      entries[i] = newEntry;
      hashCode += keyHash ^ valueHash;
    }
    return new RegularImmutableBiMap<K,hashCode);
  }

项目：codebuff    文件：RegularImmutableBiMap.java   

static <K,V>[] entries;
  if (n == entryArray.length) {
    entries = entryArray;
  } else {
    entries = createEntryArray(n);
  }
  int hashCode = 0;
  for (int i = 0; i < n; i++) {
    @SuppressWarnings("unchecked")
    Entry<K,value);
    int keyHash = key.hashCode();
    int valueHash = value.hashCode();
    int keyBucket = Hashing.smear(keyHash) & mask;
    int valueBucket = Hashing.smear(valueHash) & mask;
    ImmutableMapEntry<K,so it'd require
       * benchmarking.
       */
      boolean reusable =
              entry instanceof ImmutableMapEntry
              && ((ImmutableMapEntry<K,V>) entry).isReusable();
      newEntry = reusable ? (ImmutableMapEntry<K,value);
    } else {
      newEntry = new NonTerminalImmutableBiMapEntry<K,so it'd require
       * benchmarking.
       */
      boolean reusable =
        entry instanceof ImmutableMapEntry
        && ((ImmutableMapEntry<K,hashCode);
}

项目：VectorAttackScanner    文件：RegularImmutableBiMap.java   

/**
 * Constructor for RegularImmutableBiMap that makes no assumptions about the input entries.
 */
RegularImmutableBiMap(int n,Entry<?,?>[] entriesToAdd) {
  checkPositionIndex(n,entriesToAdd.length);
  int tableSize = Hashing.closedTableSize(n,MAX_LOAD_FACTOR);
  this.mask = tableSize - 1;
  ImmutableMapEntry<K,V>[] valueTable = createEntryArray(tableSize);
  ImmutableMapEntry<K,V>[] entries = createEntryArray(n);
  int hashCode = 0;

  for (int i = 0; i < n; i++) {
    @SuppressWarnings("unchecked")
    Entry<K,V> entry = (Entry<K,V>) entriesToAdd[i];
    K key = entry.getKey();
    V value = entry.getValue();
    checkEntryNotNull(key,V> newEntry;
    if (nextInValueBucket == null && nextInKeyBucket == null) {
      /*
       * Todo(user): consider using a NonTerminalImmutableMapEntry when nextInKeyBucket is
       * nonnull but nextInValueBucket is null.  This may save a few bytes on some platforms,so it'd require
       * benchmarking.
       */
      boolean reusable = entry instanceof ImmutableMapEntry
          && ((ImmutableMapEntry<K,V>(
          key,nextInValueBucket);
    }
    keyTable[keyBucket] = newEntry;
    valueTable[valueBucket] = newEntry;
    entries[i] = newEntry;
    hashCode += keyHash ^ valueHash;
  }

  this.keyTable = keyTable;
  this.valueTable = valueTable;
  this.entries = entries;
  this.hashCode = hashCode;
}

项目：guava    文件：RegularImmutableBiMap.java   

static <K,value);
    } else {
      newEntry =
          new NonTerminalImmutableBiMapEntry<>(key,nextInValueBucket);
    }
    keyTable[keyBucket] = newEntry;
    valueTable[valueBucket] = newEntry;
    entries[i] = newEntry;
    hashCode += keyHash ^ valueHash;
  }
  return new RegularImmutableBiMap<>(keyTable,hashCode);
}