Beispiel #1
0
  public static void main(String[] args) throws Exception {
    System.out.println("Starting Cache Client...");
    int bucket;

    List<CacheServiceInterface> serverlist = new ArrayList<CacheServiceInterface>();
    serverlist.add(new DistributedCacheService("http://localhost:3000"));
    serverlist.add(new DistributedCacheService("http://localhost:3001"));
    serverlist.add(new DistributedCacheService("http://localhost:3002"));

    CharSequence val;
    for (int key = 1; key <= 10; key++) {
      val = generateRandomChar();
      bucket =
          Hashing.consistentHash(
              Hashing.md5().hashString(Integer.toString(key)), serverlist.size());
      serverlist.get(bucket).put(key, val.toString());

      System.out.println("put (key " + key + " and value " + val + ")" + " in bucket " + bucket);
    }
    for (int key = 1; key <= 10; key++) {
      bucket =
          Hashing.consistentHash(
              Hashing.md5().hashString(Integer.toString(key)), serverlist.size());
      System.out.println(
          "get (key "
              + key
              + " and value "
              + serverlist.get(bucket).get(key)
              + ")"
              + "from bucket "
              + bucket);
    }

    System.out.println("Exiting Cache Client...");
  }
 // goodFastHash(128) uses Murmur3_128. Use the same epsilon bounds.
 public void testGoodFastHash128() {
   HashTestUtils.check2BitAvalanche(Hashing.goodFastHash(128), 250, 0.20);
   HashTestUtils.checkAvalanche(Hashing.goodFastHash(128), 250, 0.17);
   HashTestUtils.checkNo2BitCharacteristics(Hashing.goodFastHash(128));
   HashTestUtils.checkNoFunnels(Hashing.goodFastHash(128));
   HashTestUtils.assertInvariants(Hashing.goodFastHash(128));
 }
  @Test
  public void shouldSetUpAPrivateLibraryIfGivenAMavenCoordWithoutDeps() throws Exception {
    resolver.resolve("com.example:no-deps:jar:1.0");

    Path groupDir = thirdParty.resolve("example");
    assertTrue(Files.exists(groupDir));

    Path original = repo.resolve("com/example/no-deps/1.0/no-deps-1.0.jar");
    HashCode expected = MorePaths.asByteSource(original).hash(Hashing.sha1());
    Path jarFile = groupDir.resolve("no-deps-1.0.jar");
    HashCode seen = MorePaths.asByteSource(jarFile).hash(Hashing.sha1());
    assertEquals(expected, seen);

    List<Map<String, Object>> rules = buildFileParser.getAll(groupDir.resolve("BUCK"));

    assertEquals(1, rules.size());
    Map<String, Object> rule = rules.get(0);
    // Name is derived from the project identifier
    assertEquals("no-deps", rule.get("name"));

    // The binary jar should be set
    assertEquals("no-deps-1.0.jar", rule.get("binaryJar"));

    // There was no source jar in the repo
    assertTrue(rule.containsKey("sourceJar"));
    assertNull(rule.get("sourceJar"));

    // Nothing depends on this, so it's not visible
    assertEquals(ImmutableList.of(), rule.get("visibility"));

    // And it doesn't depend on anything
    assertEquals(ImmutableList.of(), rule.get("deps"));
  }
 public void testMurmur3_32() {
   HashTestUtils.check2BitAvalanche(Hashing.murmur3_32(), 250, 0.20);
   HashTestUtils.checkAvalanche(Hashing.murmur3_32(), 250, 0.17);
   HashTestUtils.checkNo2BitCharacteristics(Hashing.murmur3_32());
   HashTestUtils.checkNoFunnels(Hashing.murmur3_32());
   HashTestUtils.assertInvariants(Hashing.murmur3_32());
 }
Beispiel #5
0
  @Test
  public void testGeneratesDifferentIdenticonForDifferentHash() {
    byte[] hash = Hashing.sha256().hashString("test", UTF_8).asBytes();
    byte[] hash2 = Hashing.sha256().hashString("test2", UTF_8).asBytes();

    BufferedImage image = identicon.generate(hash);
    BufferedImage image2 = identicon.generate(hash2);

    assertThat(getImageBytes(image)).isNotEqualTo(getImageBytes(image2));
  }
 public void testCombineUnordered() {
   HashCode hash31 = HashCodes.fromInt(31);
   HashCode hash32 = HashCodes.fromInt(32);
   assertEquals(hash32, Hashing.combineUnordered(ImmutableList.of(hash32)));
   assertEquals(HashCodes.fromInt(64), Hashing.combineUnordered(ImmutableList.of(hash32, hash32)));
   assertEquals(
       HashCodes.fromInt(96), Hashing.combineUnordered(ImmutableList.of(hash32, hash32, hash32)));
   assertEquals(
       Hashing.combineUnordered(ImmutableList.of(hash31, hash32)),
       Hashing.combineUnordered(ImmutableList.of(hash32, hash31)));
 }
  @Test
  public void mappedServersTest() {

    Map<Integer, String> servers = new HashMap<>();
    servers.put(0, "server0");
    servers.put(1, "server1");

    HashFunction md5 = Hashing.md5();
    List<PartitionEntry> triggers = generateTriggers(3, 1000);

    Map<Integer, String> newPartition;
    Map<Integer, String> oldPartition;

    print("initial - test 2 servers " + servers.toString());
    newPartition = new HashMap<>();
    for (PartitionEntry trigger : triggers) {
      newPartition.put(
          trigger.hashCode(),
          servers.get(Hashing.consistentHash(md5.hashInt(trigger.hashCode()), 2)));
    }

    for (int buckets = 3; buckets < 10; buckets++) {

      servers.put(buckets - 1, "server" + (buckets - 1));
      print("test " + buckets + " servers " + servers.toString());

      oldPartition = newPartition;
      newPartition = new HashMap<>();
      for (PartitionEntry trigger : triggers) {
        newPartition.put(
            trigger.hashCode(),
            servers.get(Hashing.consistentHash(md5.hashInt(trigger.hashCode()), buckets)));
      }

      int changes = comparePartitions(oldPartition, newPartition);
      print(
          "Changes from "
              + (buckets - 1)
              + "  to "
              + buckets
              + " servers: "
              + changes
              + " of "
              + oldPartition.size());
      print("" + (((float) changes / (float) oldPartition.size()) * 100) + " % moved");
      print(
          "K("
              + oldPartition.size()
              + ")/n("
              + buckets
              + "): "
              + ((float) oldPartition.size() / (float) buckets));
    }
  }
  public void testCombineUnordered_randomHashCodes() {
    Random random = new Random();
    List<HashCode> hashCodes = Lists.newArrayList();
    for (int i = 0; i < 10; i++) {
      hashCodes.add(HashCodes.fromLong(random.nextLong()));
    }
    HashCode hashCode1 = Hashing.combineUnordered(hashCodes);
    Collections.shuffle(hashCodes);
    HashCode hashCode2 = Hashing.combineUnordered(hashCodes);

    assertEquals(hashCode1, hashCode2);
  }
 private String generateHash(@Nonnull List<TableRow> rows) {
   List<HashCode> rowHashes = Lists.newArrayList();
   for (TableRow row : rows) {
     List<String> cellsInOneRow = Lists.newArrayList();
     for (TableCell cell : row.getF()) {
       cellsInOneRow.add(Objects.toString(cell.getV()));
       Collections.sort(cellsInOneRow);
     }
     rowHashes.add(Hashing.sha1().hashString(cellsInOneRow.toString(), StandardCharsets.UTF_8));
   }
   return Hashing.combineUnordered(rowHashes).toString();
 }
 public void testCombineOrdered() {
   HashCode hash31 = HashCodes.fromInt(31);
   HashCode hash32 = HashCodes.fromInt(32);
   assertEquals(hash32, Hashing.combineOrdered(ImmutableList.of(hash32)));
   assertEquals(
       HashCodes.fromBytes(new byte[] {(byte) 0x80, 0, 0, 0}),
       Hashing.combineOrdered(ImmutableList.of(hash32, hash32)));
   assertEquals(
       HashCodes.fromBytes(new byte[] {(byte) 0xa0, 0, 0, 0}),
       Hashing.combineOrdered(ImmutableList.of(hash32, hash32, hash32)));
   assertFalse(
       Hashing.combineOrdered(ImmutableList.of(hash31, hash32))
           .equals(Hashing.combineOrdered(ImmutableList.of(hash32, hash31))));
 }
Beispiel #11
0
  public static void main(String[] args) throws Exception {
    System.out.println("Starting Cache Client...");
    String[] value = {
      "0",
      "Ferrari 250 GTO",
      "Ferrari 250 Testa Rossa",
      "Jaguar XJ13",
      "Mercedes-Benz SLR McLaren",
      "Ferrari 330 P4",
      "Maybach Exelero",
      "Rolls-Royce Hyperion",
      "Lamborghini Veneno",
      "Zenvo ST1",
      "Audi Le Mans Concept",
      " McLaren X-1 Concept",
      "Koenigsegg CCXR Trevita"
    };
    List<DistributedCacheService> server = new ArrayList<DistributedCacheService>();
    server.add(new DistributedCacheService("http://localhost:3000"));
    server.add(new DistributedCacheService("http://localhost:3001"));
    server.add(new DistributedCacheService("http://localhost:3002"));

    System.out.println(" ----------------------Putting values to server------------------");
    for (int putkey = 1; putkey <= 12; putkey++) {
      int bucket =
          Hashing.consistentHash(Hashing.md5().hashString(Integer.toString(putkey)), server.size());
      server.get(bucket).put(putkey, value[putkey]);
      System.out.println(
          "The key value pair "
              + putkey
              + "-"
              + value[putkey]
              + " is assigned to server "
              + bucket);
    }
    System.out.println(" ----------------------Getting values from server------------------");
    for (int getkey = 1; getkey <= 12; getkey++) {
      int bucket =
          Hashing.consistentHash(Hashing.md5().hashString(Integer.toString(getkey)), server.size());
      System.out.println(
          "The key value pair "
              + getkey
              + "-"
              + server.get(bucket).get(getkey)
              + " is received to server "
              + bucket);
    }
    System.out.println(" ------------------------------Terminated---------------------------");
  }
Beispiel #12
0
 public HashCode getOutputHash(FileHashCache fileHashCache) throws IOException {
   Hasher hasher = Hashing.md5().newHasher();
   for (Path path : getRecordedPaths()) {
     hasher.putBytes(fileHashCache.get(path).asBytes());
   }
   return hasher.hash();
 }
  @Test
  public void testOnConnected() throws Exception {
    String password = "******";

    when(userService.getPassword()).thenReturn(password);
    instance.connect();

    botStartedFuture.get(TIMEOUT, TIMEOUT_UNIT);

    CountDownLatch latch = new CountDownLatch(1);
    doAnswer(
            invocation -> {
              latch.countDown();
              return null;
            })
        .when(outputIrc)
        .joinChannel(DEFAULT_CHANNEL_NAME);

    mockTaskService();
    instance.connectionStateProperty().set(ConnectionState.CONNECTED);

    String md5Password = Hashing.md5().hashString(password, StandardCharsets.UTF_8).toString();
    verify(outputIrc).message("NICKSERV", String.format("IDENTIFY %s", md5Password));

    assertTrue("Channel has not been joined within timeout", latch.await(TIMEOUT, TIMEOUT_UNIT));
  }
Beispiel #14
0
 public static Inet4Address getCoercedIPv4Address(InetAddress paramInetAddress) {
   if ((paramInetAddress instanceof Inet4Address)) {
     return (Inet4Address) paramInetAddress;
   }
   byte[] arrayOfByte = paramInetAddress.getAddress();
   int i = 1;
   for (int j = 0; j < 15; j++) {
     if (arrayOfByte[j] != 0) {
       i = 0;
       break;
     }
   }
   if ((i != 0) && (arrayOfByte[15] == 1)) {
     return LOOPBACK4;
   }
   if ((i != 0) && (arrayOfByte[15] == 0)) {
     return ANY4;
   }
   Inet6Address localInet6Address = (Inet6Address) paramInetAddress;
   long l = 0L;
   if (hasEmbeddedIPv4ClientAddress(localInet6Address)) {
     l = getEmbeddedIPv4ClientAddress(localInet6Address).hashCode();
   } else {
     l = ByteBuffer.wrap(localInet6Address.getAddress(), 0, 8).getLong();
   }
   int k = Hashing.murmur3_32().hashLong(l).asInt();
   k |= 0xE0000000;
   if (k == -1) {
     k = -2;
   }
   return getInet4Address(Ints.toByteArray(k));
 }
  public static void main(String[] args) throws IOException {
    Closer closer = Closer.create();
    // copy a file
    File origin = new File("join_temp");
    File copy = new File("target_temp");

    try {
      BufferedReader reader = new BufferedReader(new FileReader("join_temp"));
      BufferedWriter writer = new BufferedWriter(new FileWriter("target_temp"));

      closer.register(reader);
      closer.register(writer);

      String line;

      while ((line = reader.readLine()) != null) {
        writer.write(line);
      }
    } catch (IOException e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }

    Files.copy(origin, copy);

    File moved = new File("moved");

    // moving renaming
    Files.move(copy, moved);

    // working files as string
    List<String> lines = Files.readLines(origin, Charsets.UTF_8);

    HashCode hashCode = Files.hash(origin, Hashing.md5());
    System.out.println(hashCode);

    // file write and append
    String hamlet = "To be, or not to be it is a question\n";
    File write_and_append = new File("write_and_append");

    Files.write(hamlet, write_and_append, Charsets.UTF_8);

    Files.append(hamlet, write_and_append, Charsets.UTF_8);

    //        write_and_append.deleteOnExit();

    Files.write("OverWrite the file", write_and_append, Charsets.UTF_8);

    // ByteSource ByteSink
    ByteSource fileBytes = Files.asByteSource(write_and_append);
    byte[] readBytes = fileBytes.read();
    // equals to pre line -> Files.toByteArray(write_and_append) == readBytes

    ByteSink fileByteSink = Files.asByteSink(write_and_append);
    fileByteSink.write(Files.toByteArray(write_and_append));

    BaseEncoding base64 = BaseEncoding.base64();
    System.out.println(base64.encode("123456".getBytes()));
  }
  public static Result processFile(Path prev, Path cur, Path outDir, int num, int gzipFrom)
      throws IOException {
    Result deltaHashes = new Result();
    Path deltaFile = outDir.resolve(cur.getFileName().toString() + ".bpatch");
    deleteIfExists(deltaFile);
    deltaHashes.path = deltaFile;

    boolean isGzipping = num >= gzipFrom;
    try (HashingOutputStream hashingStream =
        new HashingOutputStream(
            Hashing.sha256(),
            new BufferedOutputStream(newOutputStream(deltaFile, StandardOpenOption.CREATE_NEW)))) {
      GZIPOutputStream zipStream = null;
      GDiffWriter writer;
      if (isGzipping) {
        // Just constructing this object writes to the stream.
        zipStream = new GZIPOutputStream(hashingStream);
        writer = new GDiffWriter(zipStream);
      } else {
        writer = new GDiffWriter(hashingStream);
      }
      Delta delta = new Delta();
      deltaHashes.preHash = sha256(readAllBytes(prev));
      delta.compute(prev.toFile(), cur.toFile(), writer);
      if (isGzipping) zipStream.close();
      deltaHashes.patchHash = hashingStream.hash().asBytes();
      deltaHashes.postHash = sha256(readAllBytes(cur));
    }
    long size = Files.size(deltaFile);
    deltaHashes.patchSize = size;
    println("... done: %s   (%.2fkb) %s", deltaFile, size / 1024.0, isGzipping ? "zipped" : "");
    return deltaHashes;
  }
/** Splits input by hashing the key. */
public class HashingSharder implements Sharder {

  private static final long serialVersionUID = 7967187256546710108L;
  private static final HashFunction HASH = Hashing.murmur3_32();
  private int numShards;

  public HashingSharder(int numShards) {
    this.numShards = numShards;
    checkArgument(numShards > 0);
  }

  @Override
  public int getNumShards() {
    return numShards;
  }

  @Override
  public int getShardForKey(ByteBuffer key) {
    byte[] bytes = SerializationUtil.getBytes(key);
    int hash = (HASH.hashBytes(bytes).asInt()) & Integer.MAX_VALUE; // Keeping positive
    // Dividing integer range rather than using modulo so as to avoid rewriting entries if they are
    // re-hashed.
    return hash / (Integer.MAX_VALUE / numShards + 1);
  }
}
  private void addDirectoryToZipEntryList(
      File directory, String currentPath, ImmutableMap.Builder<File, ZipEntry> zipEntriesBuilder)
      throws IOException {
    Preconditions.checkNotNull(currentPath);

    for (File inputFile : directory.listFiles()) {
      String childPath = currentPath + (currentPath.isEmpty() ? "" : "/") + inputFile.getName();

      if (inputFile.isDirectory()) {
        addDirectoryToZipEntryList(inputFile, childPath, zipEntriesBuilder);
      } else {
        ZipEntry nextEntry = new ZipEntry(childPath);
        long fileLength = inputFile.length();
        if (fileLength > maxDeflatedBytes
            || EXTENSIONS_NOT_TO_DEFLATE.contains(Files.getFileExtension(inputFile.getName()))) {
          nextEntry.setMethod(ZipEntry.STORED);
          nextEntry.setCompressedSize(inputFile.length());
          nextEntry.setSize(inputFile.length());
          HashCode crc = ByteStreams.hash(Files.newInputStreamSupplier(inputFile), Hashing.crc32());
          nextEntry.setCrc(crc.padToLong());
        }

        zipEntriesBuilder.put(inputFile, nextEntry);
      }
    }
  }
 public String generateAttributesHash(HttpRequestContext request) {
   StringBuilder attr = new StringBuilder();
   attr.append(request.getHeaderValue("User-Agent"));
   //        attr.append(request.getRequestUri().getHost()); TODO: add remote ip address after you
   // find how to get remote IP from HttpContext
   return Hashing.sha256().hashString(attr.toString(), StandardCharsets.UTF_8).toString();
 }
 public void testCombineUnordered_null() {
   try {
     Hashing.combineUnordered(null);
     fail();
   } catch (NullPointerException expected) {
   }
 }
Beispiel #21
0
  /**
   * Constructor. Initializes the RLBS Bloom Filter.
   *
   * @param k number of simple Bloom Filters composing this instance
   */
  public RLBSBloomFilter(int k, int m, double thresFPR) {
    // Initialize parameters and calculate derived ones
    this.thresFPR = thresFPR;
    this.m = m;
    this.k = k;
    this.bitSetSize = (int) (m / k);

    // Prepare the hash functions to map items to positions in the bit array
    this.arrHashFunctions = new HashFunction[k];
    this.arrBitSets = new BitSet[k];

    for (int i = 0; i < k; i++) {
      // Murmur3 hashing functions, having different seeds are independent from each other
      this.arrHashFunctions[i] = Hashing.murmur3_128(i);
      // Each bit array implements a memory of m/k bit positions
      this.arrBitSets[i] = new BitSet(this.bitSetSize);
    }

    // Compute suggessted k, according to Bera et al. (pg. 24)
    double computedK = (Math.log(this.thresFPR) / Math.log(1 - (1 / Math.E)));

    logger.info(
        "RLBSBF initialized. Memory size (m): {}, Hash-functions: {}, Suggested Hash-functions: {}",
        this.m,
        this.k,
        computedK);
  }
  @Override
  public void scrubFile(FileChannel file) throws IOException, ScrubException {
    if (!Machos.isMacho(file)) {
      return;
    }

    long size = file.size();
    MappedByteBuffer map = file.map(FileChannel.MapMode.READ_WRITE, 0, size);

    try {
      Machos.setUuid(map, ZERO_UUID);
    } catch (Machos.MachoException e) {
      throw new ScrubException(e.getMessage());
    }
    map.rewind();

    Hasher hasher = Hashing.sha1().newHasher();
    while (map.hasRemaining()) {
      hasher.putByte(map.get());
    }

    map.rewind();
    try {
      Machos.setUuid(map, Arrays.copyOf(hasher.hash().asBytes(), 16));
    } catch (Machos.MachoException e) {
      throw new ScrubException(e.getMessage());
    }
  }
 public void testCombineUnordered_differentBitLengths() {
   try {
     Hashing.combineUnordered(ImmutableList.of(HashCodes.fromInt(32), HashCodes.fromLong(32L)));
     fail();
   } catch (IllegalArgumentException expected) {
   }
 }
 public void testGoodFastHash() {
   for (int i = 1; i < 200; i += 17) {
     HashFunction hasher = Hashing.goodFastHash(i);
     assertTrue(hasher.bits() >= i);
     HashTestUtils.assertInvariants(hasher);
   }
 }
 /** Walk project references recursively, adding thrift files to the provided list. */
 List<File> getRecursiveThriftFiles(MavenProject project, String outputDirectory, List<File> files)
     throws IOException {
   HashFunction hashFun = Hashing.md5();
   if (dependencyIncludes.contains(project.getArtifactId())) {
     File dir = new File(new File(project.getFile().getParent(), "target"), outputDirectory);
     if (dir.exists()) {
       URI baseDir = getFileURI(dir);
       for (File f : findThriftFilesInDirectory(dir)) {
         URI fileURI = getFileURI(f);
         String relPath = baseDir.relativize(fileURI).getPath();
         File destFolder = getResourcesOutputDirectory();
         destFolder.mkdirs();
         File destFile = new File(destFolder, relPath);
         if (!destFile.exists()
             || (destFile.isFile()
                 && !Files.hash(f, hashFun).equals(Files.hash(destFile, hashFun)))) {
           getLog()
               .info(
                   format("copying %s to %s", f.getCanonicalPath(), destFile.getCanonicalPath()));
           copyFile(f, destFile);
         }
         files.add(destFile);
       }
     }
   }
   Map<String, MavenProject> refs = project.getProjectReferences();
   for (String name : refs.keySet()) {
     getRecursiveThriftFiles(refs.get(name), outputDirectory, files);
   }
   return files;
 }
Beispiel #26
0
  public void sendUpUserMessage() throws IOException {
    Properties properties = new Properties();
    properties.put("metadata.broker.list", "10.1.3.55:9092,10.1.3.56:9092,10.1.3.59:9092");
    properties.put("serializer.class", "kafka.serializer.StringEncoder");
    ProducerConfig producerConfig = new ProducerConfig(properties);
    kafka.javaapi.producer.Producer<String, String> producer =
        new kafka.javaapi.producer.Producer<String, String>(producerConfig);

    InputStream in = this.getClass().getResourceAsStream("/upusers.csv");
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    String line = null;
    while ((line = reader.readLine()) != null) {
      // System.out.println(line);
      ArrayList<String> list =
          new ArrayList<String>(Arrays.asList(line.replace(";NULL", "").split(",")));
      if (list.size() != 0) {
        list.remove(0);
        String uid = list.remove(0);
        String nline =
            Hashing.md5()
                    .hashString(
                        uid + System.currentTimeMillis() + new Random().nextLong(), Charsets.UTF_8)
                + ","
                + Joiner.on(",").join(list.toArray()).toString();
        // String nline = Joiner.on(",").join(list.toArray()).toString();
        KeyedMessage<String, String> message = new KeyedMessage<String, String>(TOPIC, nline);
        producer.send(message);
        // System.out.println(nline);
        // System.out.println(nline);
      }
    }
  }
  @Test
  public void testComputeAbiKey() {
    ImmutableSortedMap<String, HashCode> classNamesAndHashes =
        ImmutableSortedMap.of(
            "com/example/Foo", HashCode.fromString("e4fccb7520b7795e632651323c63217c9f59f72a"),
            "com/example/Bar", HashCode.fromString("087b7707a5f8e0a2adf5652e3cd2072d89a197dc"),
            "com/example/Baz", HashCode.fromString("62b1c2510840c0de55c13f66065a98a719be0f19"));
    String observedSha1 = DexProducedFromJavaLibrary.computeAbiKey(classNamesAndHashes).getHash();

    String expectedSha1 =
        Hashing.sha1()
            .newHasher()
            .putUnencodedChars("com/example/Bar")
            .putByte((byte) 0)
            .putUnencodedChars("087b7707a5f8e0a2adf5652e3cd2072d89a197dc")
            .putByte((byte) 0)
            .putUnencodedChars("com/example/Baz")
            .putByte((byte) 0)
            .putUnencodedChars("62b1c2510840c0de55c13f66065a98a719be0f19")
            .putByte((byte) 0)
            .putUnencodedChars("com/example/Foo")
            .putByte((byte) 0)
            .putUnencodedChars("e4fccb7520b7795e632651323c63217c9f59f72a")
            .putByte((byte) 0)
            .hash()
            .toString();
    assertEquals(expectedSha1, observedSha1);
  }
 public void testCombineUnordered_empty() {
   try {
     Hashing.combineUnordered(Collections.<HashCode>emptySet());
     fail();
   } catch (IllegalArgumentException expected) {
   }
 }
Beispiel #29
0
 /**
  * Non-idempotent RuleKeys are normally output as strings of 'x' characters, but when comparing
  * two sets of RuleKeys in textual form it is necessary to mangle one of the two sets, so that
  * non-idempotent RuleKeys are never considered equal.
  */
 public String toString(boolean mangleNonIdempotent) {
   if (!isIdempotent()) {
     return new String(new char[Hashing.sha1().bits() / 4])
         .replace("\0", mangleNonIdempotent ? "y" : "x");
   }
   return hashCode.toString();
 }
  private static final class PeriodSelector<K> implements Function<K, Period> {
    private static final HashFunction hasher = Hashing.goodFastHash(Integer.SIZE);
    private final ImmutableList<Period> periods;
    private final long totalSize;

    public PeriodSelector(final Iterable<? extends Period> periods) {
      this.periods = ImmutableList.copyOf(periods);
      long size = 0L;
      for (final Period period : this.periods) {
        size += period.size;
      }
      this.totalSize = size;
    }

    /**
     * Imagine all of the periods provided in the constructor laid end to end on a number line, each
     * the length of its size, stretching from zero to the sum of all of the sizes. Hash the given
     * key and mod it with that sum to yield a position along that number line. Then identify the
     * period that covers that portion of the value. This approach has the benefit of being both
     * fast and deterministic for a given key.
     */
    @Override
    public Period apply(final K elementKey) {
      // Rehash for better bit dispersion:
      final int hashCode = hasher.hashInt(elementKey.hashCode()).asInt();
      final long value = hashCode % this.totalSize;
      int i = 0;
      for (int bound = 0;
          i < this.periods.size() && value >= (bound += this.periods.get(i).size);
          ++i) {
        // do nothing
      }
      return this.periods.get(i);
    }
  }