Java Hasher.putChar方法代码示例

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
/**
 * Obtains the {@code HashCode} for the contents of {@code value}.
 *
 * @param value a {@code CheckRequest} to be signed
 * @return the {@code HashCode} corresponding to {@code value}
 */
public static HashCode sign(CheckRequest value) {
  Hasher h = Hashing.md5().newHasher();
  Operation o = value.getOperation();
  if (o == null || Strings.isNullOrEmpty(o.getConsumerId())
      || Strings.isNullOrEmpty(o.getOperationName())) {
    throw new IllegalArgumentException("CheckRequest should have a valid operation");
  }
  h.putString(o.getConsumerId(), StandardCharsets.UTF_8);
  h.putChar('\0');
  h.putString(o.getOperationName(), StandardCharsets.UTF_8);
  h.putChar('\0');
  Signing.putLabels(h, o.getLabels());
  for (MetricValueSet mvSet : o.getMetricValueSetsList()) {
    h.putString(mvSet.getMetricName(), StandardCharsets.UTF_8);
    h.putChar('\0');
    for (MetricValue metricValue : mvSet.getMetricValuesList()) {
      MetricValues.putMetricValue(h, metricValue);
    }
  }
  return h.hash();
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
@VisibleForTesting
static HashCode sign(AllocateQuotaRequest req) {
  Hasher h = Hashing.md5().newHasher();
  QuotaOperation o = req.getAllocateOperation();
  h.putString(o.getMethodName(), StandardCharsets.UTF_8);
  h.putChar('\0');
  h.putString(o.getConsumerId(), StandardCharsets.UTF_8);
  ImmutableSortedSet.Builder<String> builder =
      new ImmutableSortedSet.Builder<>(Ordering.natural());
  for (MetricValueSet mvSet : o.getQuotaMetricsList()) {
    builder.add(mvSet.getMetricName());
  }
  for (String metricName : builder.build()) {
    h.putChar('\0');
    h.putString(metricName, StandardCharsets.UTF_8);
  }
  return h.hash();
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
@Test
public void testBasics() {
    Hasher hasher = NullHasher.INSTANCE;
    assertEquals(0, hasher.hash().asInt());
    hasher.putBoolean(false);
    hasher.putByte((byte) 3);
    hasher.putBytes(new byte[0]);
    hasher.putBytes(null, 3, 3);
    hasher.putChar('c');
    hasher.putDouble(3.3);
    hasher.putFloat(3.4f);
    hasher.putInt(7);
    hasher.putLong(3);
    hasher.putObject(null, null);
    hasher.putShort((short) 7);
    hasher.putString(null, null);
    hasher.putUnencodedChars(null);
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
/**
 * Computes a hash code for the given {@link #getEClass(EObject) EClass} and {@link #getQualifiedName(EObject) qualified name}.
 *
 * @param eClass
 *          EClass to base hash on, must not be {@code null}
 * @param name
 *          qualified name of inferred model element, can be {@code null}
 * @return hash code, never {@code null}
 */
protected HashCode computeHash(final EClass eClass, final QualifiedName name) {
  byte[] eClassUriBytes = eClassToUriBytesMap.get(eClass);
  if (eClassUriBytes == null) {
    eClassUriBytes = EcoreUtil.getURI(eClass).toString().getBytes(Charsets.UTF_8);
    eClassToUriBytesMap.put(eClass, eClassUriBytes);
  }

  Hasher hasher = hashFunction.newHasher(HASHER_CAPACITY);
  hasher.putBytes(eClassUriBytes);

  if (name != null) {
    hasher.putChar('/');

    for (int j = 0; j < name.getSegmentCount(); j++) {
      hasher.putUnencodedChars(name.getSegment(j)).putChar('.');
    }
  }

  return hasher.hash();
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
public void hashObject(Hasher hasher, boolean millisecondsRemoved) {
    hasher
        .putString("FileState", Charsets.UTF_8)
        .putChar(HASH_FIELD_SEPARATOR)
        .putString(fileName, Charsets.UTF_8)
        .putChar(HASH_FIELD_SEPARATOR)
        .putLong(fileLength);

    hasher.putChar(HASH_OBJECT_SEPARATOR);
    fileTime.hashObject(hasher, millisecondsRemoved);

    hasher.putChar(HASH_OBJECT_SEPARATOR);
    fileHash.hashObject(hasher);

    hasher.putChar(HASH_OBJECT_SEPARATOR);
    if (fileAttributes != null) {
        for (Map.Entry<String, String> entry : fileAttributes.entrySet()) {
            hasher
                .putString(entry.getKey(), Charsets.UTF_8)
                .putChar(':')
                .putChar(':')
                .putString(entry.getValue(), Charsets.UTF_8);
            hasher.putChar(HASH_OBJECT_SEPARATOR);
        }
    }
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
/**
 * Obtains the {@hashCode} for the contents of {@code value}.
 *
 * @param value a {@code Operation} to be signed
 * @return the {@code HashCode} corresponding to {@code value}
 */
private static HashCode sign(Operation value) {
  Hasher h = Hashing.md5().newHasher();
  h.putString(value.getConsumerId(), StandardCharsets.UTF_8);
  h.putChar('\0');
  h.putString(value.getOperationName(), StandardCharsets.UTF_8);
  h.putChar('\0');
  return Signing.putLabels(h, value.getLabels()).hash();
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
@Override
public void hashObject(Hasher hasher) {
    hasher
        .putString("State", Charsets.UTF_8)
        .putChar(HASH_FIELD_SEPARATOR)
        .putString(modelVersion, Charsets.UTF_8)
        .putChar(HASH_FIELD_SEPARATOR)
        .putLong(timestamp)
        .putChar(HASH_FIELD_SEPARATOR)
        .putString(comment, Charsets.UTF_8)
        .putChar(HASH_FIELD_SEPARATOR)
        .putInt(fileCount)
        .putChar(HASH_FIELD_SEPARATOR)
        .putLong(filesContentLength)
        .putChar(HASH_FIELD_SEPARATOR)
        .putString(hashMode.name(), Charsets.UTF_8);

    hasher.putChar(HASH_OBJECT_SEPARATOR);
    for (String ignoredFile : ignoredFiles) {
        hasher
            .putString(ignoredFile, Charsets.UTF_8)
            .putChar(HASH_OBJECT_SEPARATOR);
    }

    hasher.putChar(HASH_OBJECT_SEPARATOR);
    for (FileState fileState : fileStates) {
        fileState.hashObject(hasher);
        hasher.putChar(HASH_OBJECT_SEPARATOR);
    }
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
@Override
public Sha1HashCode apply(Iterable<HasAndroidResourceDeps> deps) {
  Hasher hasher = Hashing.sha1().newHasher();
  for (HasAndroidResourceDeps dep : deps) {
    hasher.putUnencodedChars(dep.getPathToTextSymbolsFile().toString());
    // Avoid collisions by marking end of path explicitly.
    hasher.putChar('\0');
    hasher.putUnencodedChars(dep.getTextSymbolsAbiKey().getHash());
    hasher.putUnencodedChars(dep.getRDotJavaPackage());
    hasher.putChar('\0');
  }
  return new Sha1HashCode(hasher.hash().toString());
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
@Override
public Hasher putChar(char c) {
  for (Hasher hasher : hashers) {
    hasher.putChar(c);
  }
  return this;
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
/**
 * Utility method to compute an hash string from a vararg list of objects. The returned string
 * is 16 characters long, starts with {@code A-Za-z} and contains only characters
 * {@code A-Za-z0-9}.
 *
 * @param objects
 *            the objects to compute the hash from
 * @return the computed hash string
 */
public static String hash(final Object... objects) {
    final Hasher hasher = Hashing.md5().newHasher();
    for (final Object object : objects) {
        if (object instanceof CharSequence) {
            hasher.putString((CharSequence) object, Charsets.UTF_16LE);
        } else if (object instanceof byte[]) {
            hasher.putBytes((byte[]) object);
        } else if (object instanceof Character) {
            hasher.putChar((Character) object);
        } else if (object instanceof Boolean) {
            hasher.putBoolean((Boolean) object);
        } else if (object instanceof Integer) {
            hasher.putInt(((Integer) object).intValue());
        } else if (object instanceof Long) {
            hasher.putLong(((Long) object).longValue());
        } else if (object instanceof Double) {
            hasher.putDouble(((Double) object).doubleValue());
        } else if (object instanceof Float) {
            hasher.putFloat(((Float) object).floatValue());
        } else if (object instanceof Byte) {
            hasher.putByte(((Byte) object).byteValue());
        } else {
            hasher.putString(object.toString(), Charsets.UTF_16LE);
        }
    }
    final byte[] bytes = hasher.hash().asBytes();
    final StringBuilder builder = new StringBuilder(16);
    int max = 52;
    for (int i = 0; i < bytes.length; ++i) {
        final int n = (bytes[i] & 0x7F) % max;
        if (n < 26) {
            builder.append((char) (65 + n));
        } else if (n < 52) {
            builder.append((char) (71 + n));
        } else {
            builder.append((char) (n - 4));
        }
        max = 62;
    }
    return builder.toString();
}
 

import com.google.common.hash.Hasher; //导入方法依赖的package包/类
/**
 * Updates {@code h} with the contents of {@code labels}.
 *
 * {@code labels} can be any Map<String, String>, but intended to be used for the labels of
 * one of the model protobufs.
 *
 * @param h a {@link Hasher}
 * @param labels some labels
 * @return the {@code Hasher}, to allow fluent-style usage
 */
public static Hasher putLabels(Hasher h, Map<String, String> labels) {
  for (Map.Entry<String, String> labelsEntry : labels.entrySet()) {
    h.putChar('\0');
    h.putString(labelsEntry.getKey(), StandardCharsets.UTF_8);
    h.putChar('\0');
    h.putString(labelsEntry.getValue(), StandardCharsets.UTF_8);
  }
  return h;
}