Ejemplo n.º 1
0
  public static void main(String[] args) {

    // 注意BiMap的key和value都不能重复,否则inverse之后就不能保证键值一一对应了
    BiMap<String, Integer> users = HashBiMap.create();

    users.put("bandery", 10);
    users.put("ryan", 11);
    users.put("liuyan", 12);

    // 反转,key变成value,value变成key
    System.out.println(users.inverse().get(10));

    // 会有异常,key和value都不能重复
    // System.out.println(users.inverse().get(11));
    // 异常,"bandery"已经存在
    // users.put("bandery", 1);

    // 如果想插入的话,可以用forcePut强制插入,但在这之前会将相同的K或者V对应
    // 的键值对删除

    // 这样会把之前的bandery-10删除
    users.forcePut("bandery", 13);

    // 这样会把之前的ryan-11和liuyan-12都删除
    users.forcePut("ryan", 12);

    // 当然还有putAll方法
    Map<String, Integer> toadd = HashBiMap.create();
    toadd.put("aaa", 111111);
    toadd.put("bbb", 22222);
    users.putAll(toadd);
  }
  @Test
  public void whenCreateBiMap_thenCreated() {
    final BiMap<String, Integer> words = HashBiMap.create();
    words.put("First", 1);
    words.put("Second", 2);
    words.put("Third", 3);

    assertEquals(2, words.get("Second").intValue());
    assertEquals("Third", words.inverse().get(3));
  }
Ejemplo n.º 3
0
  /**
   * It marks the expression identified by the reference name as <code>evaluated</code>. In
   * addition, it adds an EvanNode for the expression identified by the reference.
   *
   * @param referenceName The reference name to be marked as 'evaluated'.
   * @param evalNode EvalNode to be added.
   */
  public void markAsEvaluated(String referenceName, EvalNode evalNode) throws PlanningException {
    String normalized = referenceName;

    int refId = nameToIdMap.get(normalized);
    evaluationStateMap.put(refId, true);
    idToEvalMap.put(refId, evalNode);

    String originalName = checkAndGetIfAliasedColumn(normalized);
    if (originalName != null) {
      aliasedColumnMap.put(originalName, normalized);
    }
  }
Ejemplo n.º 4
0
  @Test
  public void testBiMap() {
    BiMap<String, String> dataMap = HashBiMap.create();
    dataMap.put("number", "dea123");
    dataMap.put("dataEntered", "10/10/2012");
    dataMap.put("keyCode", "code00001");
    dataMap.put("isActive", "true");
    // key and value are both unique.
    dataMap.forcePut("isMember", "true");

    Assert.assertEquals("dea123", dataMap.get("number"));
    BiMap<String, String> inverseMap = dataMap.inverse();
    Assert.assertEquals("keyCode", inverseMap.get("code00001"));
    Assert.assertEquals("isMember", inverseMap.get("true"));
  }
Ejemplo n.º 5
0
 @Override
 public boolean add(TravelingItem item) {
   if (delegate.containsValue(item)) return false;
   item.setContainer(container);
   delegate.put(item.id, item);
   return true;
 }
  @Override
  protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) throws Exception {
    String request = packet.content().toString(CharsetUtil.UTF_8);
    if (logger.isDebugEnabled())
      logger.debug("Sender " + packet.sender() + " sent request:" + request);

    if (!sessionList.inverse().containsKey(packet.sender())) {
      String session = UUID.randomUUID().toString();
      String localAddress = ctx.channel().localAddress().toString();
      String remoteAddress = ctx.channel().remoteAddress().toString();
      SubscriptionManagerFactory.getInstance()
          .add(session, session, outputType, localAddress, remoteAddress);
      sessionList.put(session, packet.sender());
      if (logger.isDebugEnabled())
        logger.debug("Added Sender " + packet.sender() + ", session:" + session);
      ctx.channel()
          .writeAndFlush(
              new DatagramPacket(
                  Unpooled.copiedBuffer(
                      Util.getWelcomeMsg().toString() + "\r\n", CharsetUtil.UTF_8),
                  packet.sender()));
    }

    Map<String, Object> headers = getHeaders(sessionList.inverse().get(packet.sender()));
    producer.sendBodyAndHeaders(request, headers);
  }
Ejemplo n.º 7
0
  public void addBootstrapToken(Token token, InetAddress endpoint) {
    assert token != null;
    assert endpoint != null;

    lock.writeLock().lock();
    try {
      InetAddress oldEndPoint = null;

      oldEndPoint = bootstrapTokens.get(token);
      if (oldEndPoint != null && !oldEndPoint.equals(endpoint))
        throw new RuntimeException(
            "Bootstrap Token collision between "
                + oldEndPoint
                + " and "
                + endpoint
                + " (token "
                + token);

      oldEndPoint = tokenToEndPointMap.get(token);
      if (oldEndPoint != null && !oldEndPoint.equals(endpoint))
        throw new RuntimeException(
            "Bootstrap Token collision between "
                + oldEndPoint
                + " and "
                + endpoint
                + " (token "
                + token);

      bootstrapTokens.inverse().remove(endpoint);
      bootstrapTokens.put(token, endpoint);
    } finally {
      lock.writeLock().unlock();
    }
  }
  // Task: create collection to translate Polish-English words in two ways
  public static void main(String[] args) {
    ENGLISH_WORD[] englishWords = ENGLISH_WORD.values();
    String[] russianWords = {"jeden", "dwa", "trzy", "kula", "snieg"};

    // Create Multiset
    BiMap<ENGLISH_WORD, String> biMap = EnumHashBiMap.create(ENGLISH_WORD.class);
    // Create English-Polish dictionary
    int i = 0;
    for (ENGLISH_WORD englishWord : englishWords) {
      biMap.put(englishWord, russianWords[i]);
      i++;
    }

    // Print count words
    System.out.println(biMap); // print {ONE=jeden, TWO=dwa, THREE=trzy, BALL=kula, SNOW=snieg}
    // Print all unique words
    System.out.println(biMap.keySet()); // print [ONE, TWO, THREE, BALL, SNOW]
    System.out.println(biMap.values()); // print [jeden, dwa, trzy, kula, snieg]

    // Print translate by words
    System.out.println("one = " + biMap.get(ENGLISH_WORD.ONE)); // print one = jeden
    System.out.println("two = " + biMap.get(ENGLISH_WORD.TWO)); // print two = dwa
    System.out.println("kula = " + biMap.inverse().get("kula")); // print kula = BALL
    System.out.println("snieg = " + biMap.inverse().get("snieg")); // print snieg = SNOW
    System.out.println("empty = " + biMap.get("empty")); // print empty = null

    // Print count word's pair
    System.out.println(biMap.size()); // print 5
  }
Ejemplo n.º 9
0
 public static BiMap<Combo, Integer> getComboTuneMap() {
   int mod = getAsciiTuneMods();
   BiMap<Combo, Integer> map = HashBiMap.create();
   for (Map.Entry<Integer, Integer> entry : getAsciTuneMap().entrySet()) {
     map.put(new Combo(mod, entry.getKey()), entry.getValue());
   }
   return map;
 }
 /**
  * Create a predicate with a name associated to it. If the same name is passed again to this
  * method, the old predicate will be returned (guaranteeing uniqueness of predicate<->name
  * mapping).
  *
  * @param pName An arbitary name for a predicate.
  * @return A region representing a predicate
  */
 public Region createPredicate(String pName) {
   Region result = regionMap.get(pName);
   if (result == null) {
     result = delegate.createPredicate();
     regionMap.put(pName, result);
   }
   return result;
 }
Ejemplo n.º 11
0
 @Override
 public int enumerateLabel(String label) {
   if (!labelEnumeration.containsKey(label)) {
     labelEnumeration.put(label, nextLabel);
     nextLabel++;
   }
   return labelEnumeration.get(label);
 }
 public static Explosive register(Explosive zhaPin) {
   if (!isRegistered(zhaPin)) {
     int nextID = maxID++;
     idToExplosiveMap.put(nextID, zhaPin);
     idToNameMap.put(nextID, zhaPin.getUnlocalizedName());
     return zhaPin;
   }
   return null;
 }
Ejemplo n.º 13
0
  /**
   * Register a SubTileEntity and makes it a mini flower. Also adds the recipe and returns it.
   *
   * @see BotaniaAPI#registerSubTile
   */
  public static RecipeManaInfusion registerMiniSubTile(
      String key, Class<? extends SubTileEntity> subtileClass, String original) {
    registerSubTile(key, subtileClass);
    miniFlowers.put(original, key);

    RecipeMiniFlower recipe = new RecipeMiniFlower(key, original, 2500);
    manaInfusionRecipes.add(recipe);
    miniFlowerRecipes.add(recipe);
    return recipe;
  }
Ejemplo n.º 14
0
 public void setString(int columnIndex, String value) {
   Integer reuseIndex = stringReferences.get(value);
   if (reuseIndex != null) {
     bufferSlice.setInt(getOffset(columnIndex), reuseIndex);
   } else {
     int index = stringReferences.size();
     stringReferences.put(value, index);
     bufferSlice.setInt(getOffset(columnIndex), index);
     stringReferenceSize +=
         value.length() * 2 + 4; // assuming size of char = size of byte * 2 + length
   }
   clearNull(columnIndex);
 }
 /** {@inheritDoc} */
 public BiMap<EObject, EObject> computeMatches(
     Collection<EObject> values1, Collection<EObject> values2) {
   BiMap<EObject, EObject> result = HashBiMap.create();
   Map<Object, EObject> matchingElements = computeIds(values2);
   for (EObject obj : values1) {
     Object id1 = idFunction.apply(obj);
     EObject match = matchingElements.get(id1);
     if (match != null && values2.contains(match)) {
       result.put(obj, match);
     }
   }
   return result;
 }
Ejemplo n.º 16
0
  public void updateNormalToken(Token token, InetAddress endpoint) {
    assert token != null;
    assert endpoint != null;

    lock.writeLock().lock();
    try {
      bootstrapTokens.inverse().remove(endpoint);
      tokenToEndPointMap.inverse().remove(endpoint);
      if (!endpoint.equals(tokenToEndPointMap.put(token, endpoint))) {
        sortedTokens = sortTokens();
      }
      leavingEndPoints.remove(endpoint);
    } finally {
      lock.writeLock().unlock();
    }
  }
Ejemplo n.º 17
0
 String storeAndGenerateId(T value) {
   checkArgument(
       value instanceof Serializable,
       "When using JPPF, instances of %s must implement Serializable, "
           + "found: '%s' of class: %s.",
       clazz,
       value,
       value.getClass());
   final String id;
   if (configMap.containsKey(value)) {
     id = configMap.get(value);
   } else {
     id = prefix + idNum++;
     configMap.put(value, id);
   }
   return id;
 }
Ejemplo n.º 18
0
 public String toFieldName(String cls, String viewedClass, BigInteger rNum) {
   if (referenceFields.get(cls) == null) {
     BiMap<String, String> bimap = HashBiMap.create();
     referenceFields.put(cls, bimap);
   }
   BiMap<String, String> map = referenceFields.get(cls);
   String key = getKey(viewedClass, rNum);
   if (map.get(key) != null) return map.get(key);
   else {
     String optimalFieldName = Util.lowerFirst(Util.toJavaIdentifier(viewedClass)) + "_R" + rNum;
     String currentKey = map.inverse().get(optimalFieldName);
     String fieldName;
     if (currentKey == null) fieldName = optimalFieldName;
     else fieldName = optimalFieldName + "_R" + rNum;
     map.put(key, fieldName);
     return fieldName;
   }
 }
Ejemplo n.º 19
0
  static {
    TRAVEL_MODE_IDS.put(TravelMode.BICYCLING, "bicycling");
    TRAVEL_MODE_IDS.put(TravelMode.CAR, "car");
    TRAVEL_MODE_IDS.put(TravelMode.PUBLIC_TRANSIT, "publicTransit");
    TRAVEL_MODE_IDS.put(TravelMode.WALKING, "walking");

    TRAVEL_MODES.put(TravelMode.BICYCLING, "bicycling");
    TRAVEL_MODES.put(TravelMode.CAR, "driving");
    TRAVEL_MODES.put(TravelMode.PUBLIC_TRANSIT, "transit");
    TRAVEL_MODES.put(TravelMode.WALKING, "walking");

    ROUTE_DESCRIPTIONS.put(TravelMode.BICYCLING, "by bicycle");
    ROUTE_DESCRIPTIONS.put(TravelMode.CAR, "by car");
    ROUTE_DESCRIPTIONS.put(TravelMode.PUBLIC_TRANSIT, "by public transit");
    ROUTE_DESCRIPTIONS.put(TravelMode.WALKING, "walking");

    SUBROUTE_DESCRIPTIONS.put(TravelMode.BICYCLING, "Bicycling");
    SUBROUTE_DESCRIPTIONS.put(TravelMode.CAR, "Car");
    SUBROUTE_DESCRIPTIONS.put(TravelMode.PUBLIC_TRANSIT, "Public transit");
    SUBROUTE_DESCRIPTIONS.put(TravelMode.WALKING, "Walking");
  }
Ejemplo n.º 20
0
  public void addSkill(Class<? extends SkillTreeSkill> skillClass) {
    if (!isValidSkill(skillClass)) {
      MyPetApi.getLogger().warning(ChatColor.RED + skillClass.getName() + " is not a valid skill!");
    }
    try {
      Constructor<?> ctor = skillClass.getConstructor(boolean.class);
      Object obj = ctor.newInstance(false);
      if (obj instanceof SkillInstance) {
        SkillInstance skill = (SkillInstance) obj;
        String skillName = skill.getName();

        skill.setMyPet(this.myPet);
        skillsNamesClass.put(skillName, skill);
      }
    } catch (Exception e) {
      MyPetApi.getLogger().warning(ChatColor.RED + skillClass.getName() + " is not a valid skill!");
      e.printStackTrace();
      registeredSkillsNames.remove(skillClass);
    }
  }
Ejemplo n.º 21
0
  public static void main(String[] args) {
    BiMap<Integer, String> bm = HashBiMap.create();
    bm.put(1, "s1");
    bm.put(2, "s2");

    System.out.println(bm.get(1));
    System.out.println(bm.inverse().get("s1"));
    System.out.println(bm.getOrDefault(77, "s0"));

    // this throws and exception
    // bm.put(3, "s2");
    // this forces the new mapping
    System.out.println(bm.get(2));
    bm.forcePut(3, "s2");
    System.out.println(bm.get(2));
    System.out.println(bm.get(3));
    System.out.println(bm.inverse().get("s2"));
    // after this key 2 is gone
    bm.forcePut(1, "s2");
    System.out.println(bm);
  }
Ejemplo n.º 22
0
 public String toFieldName(String cls, String attributeName) {
   if (referenceFields.get(cls) == null) {
     BiMap<String, String> bimap = HashBiMap.create();
     referenceFields.put(cls, bimap);
   }
   BiMap<String, String> map = referenceFields.get(cls);
   String key = getKey(cls, attributeName);
   if (map.get(key) != null) return map.get(key);
   else {
     String optimalFieldName = Util.lowerFirst(Util.toJavaIdentifier(attributeName));
     String fieldName = optimalFieldName;
     if (map.inverse().get(fieldName) != null) {
       int i = 1;
       while (map.inverse().get(fieldName + i) != null) {
         i++;
       }
       fieldName = fieldName + i;
     }
     map.put(key, fieldName);
     return fieldName;
   }
 }
Ejemplo n.º 23
0
 public String toColumnName(String cls, String attributeName) {
   if (referencedColumns.get(cls) == null) {
     BiMap<String, String> bimap = HashBiMap.create();
     referencedColumns.put(cls, bimap);
   }
   BiMap<String, String> map = referencedColumns.get(cls);
   String key = getKey(cls, attributeName);
   if (map.get(key) != null) return map.get(key);
   else {
     String optimalColumnName = Util.lowerFirst(Util.toColumnName(attributeName));
     String columnName = optimalColumnName;
     if (map.inverse().get(columnName) != null || isReservedWord(columnName)) {
       int i = 1;
       while (map.inverse().get(columnName + "_" + i) != null) {
         i++;
       }
       columnName = columnName + "_" + i;
     }
     map.put(key, columnName);
     return columnName;
   }
 }
Ejemplo n.º 24
0
 public String toTableName(String schema, String className) {
   if (referencedTables.get(schema) == null) {
     BiMap<String, String> bimap = HashBiMap.create();
     referencedTables.put(schema, bimap);
   }
   BiMap<String, String> map = referencedTables.get(schema);
   String key = getKey(schema, className);
   if (map.get(key) != null) return map.get(key);
   else {
     String optimalName = Util.lowerFirst(Util.toColumnName(className));
     String name = optimalName;
     if (map.inverse().get(name) != null || isReservedWord(name)) {
       int i = 1;
       while (map.inverse().get(name + "_" + i) != null) {
         i++;
       }
       name = name + "_" + i;
     }
     map.put(key, name);
     return name;
   }
 }
 public void add(final BiMap<StringWrapper, UUID> toAdd) {
   if (uuidMap.size() == 0) {
     uuidMap = toAdd;
   }
   for (Map.Entry<StringWrapper, UUID> entry : toAdd.entrySet()) {
     UUID uuid = entry.getValue();
     StringWrapper name = entry.getKey();
     if ((uuid == null) || (name == null)) {
       continue;
     }
     BiMap<UUID, StringWrapper> inverse = uuidMap.inverse();
     if (inverse.containsKey(uuid)) {
       if (uuidMap.containsKey(name)) {
         continue;
       }
       rename(uuid, name);
       continue;
     }
     uuidMap.put(name, uuid);
   }
   PS.debug(C.PREFIX.s() + "&6Cached a total of: " + uuidMap.size() + " UUIDs");
 }
  /**
   * Generates random squares for the pieces of the provided tablebase.
   *
   * @param tablebase computerized database containing all possible legal chess positions and their
   *     evaluations, given the set of specific chess pieces
   * @return the bidirectional map from the pieces present in this chess position, to the squares
   *     they occupy
   */
  static BiMap<Piece, Square> generateRandomSquaresForPieces(Tablebase tablebase) {
    BiMap<Piece, Square> piecesWithSquares = EnumBiMap.create(Piece.class, Square.class);
    List<Piece> pieces = tablebase.getAllPieces();

    MersenneTwisterFast numberGenerator = new MersenneTwisterFast();

    Square randSquare = null;
    for (Piece piece : pieces) {
      do {
        if (piece.getPieceType() == PieceType.PAWN) {
          int pRand = numberGenerator.nextInt(Squares.PAWN_SQUARES.numberOfSquares());
          randSquare = Squares.PAWN_SQUARES.getSquaresAsList().get(pRand);
        } else {
          int allRand = numberGenerator.nextInt(Squares.ALL_SQUARES.numberOfSquares());
          randSquare = Squares.ALL_SQUARES.getSquaresAsList().get(allRand);
        }
      } while (piecesWithSquares.containsValue(randSquare));

      piecesWithSquares.put(piece, randSquare);
    }
    return piecesWithSquares;
  }
Ejemplo n.º 27
0
  /**
   * Adds an expression with an alias name and returns a reference name. It specifies the alias as
   * an reference name.
   */
  public String addExpr(Expr expr, String alias) throws PlanningException {

    // if this name already exists, just returns the name.
    if (nameToIdMap.containsKey(alias)) {
      return alias;
    }

    // if the name is first
    int refId;
    if (idToExprBiMap.inverse().containsKey(expr)) {
      refId = idToExprBiMap.inverse().get(expr);
    } else {
      refId = getNextId();
      idToExprBiMap.put(refId, expr);
    }

    nameToIdMap.put(alias, refId);
    evaluationStateMap.put(refId, false);

    // add the entry to idToNames map
    TUtil.putToNestedList(idToNamesMap, refId, alias);

    return alias;
  }
Ejemplo n.º 28
0
 static {
   for (Suit s : Suit.values()) {
     sMap.put(s.ordinal(), s);
   }
 }
Ejemplo n.º 29
0
  public Symbols(BytecodeCompleter bytecodeCompleter) {
    defaultPackage = new JavaSymbol.PackageJavaSymbol("", rootPackage);

    predefClass = new JavaSymbol.TypeJavaSymbol(Flags.PUBLIC, "", rootPackage);
    predefClass.members = new Scope(predefClass);
    ((JavaType.ClassJavaType) predefClass.type).interfaces = ImmutableList.of();

    // TODO should have type "noType":
    noSymbol = new JavaSymbol.TypeJavaSymbol(0, "", rootPackage);

    methodClass = new JavaSymbol.TypeJavaSymbol(Flags.PUBLIC, "", noSymbol);

    // builtin types
    byteType = initType(JavaType.BYTE, "byte");
    charType = initType(JavaType.CHAR, "char");
    shortType = initType(JavaType.SHORT, "short");
    intType = initType(JavaType.INT, "int");
    longType = initType(JavaType.LONG, "long");
    floatType = initType(JavaType.FLOAT, "float");
    doubleType = initType(JavaType.DOUBLE, "double");
    booleanType = initType(JavaType.BOOLEAN, "boolean");
    nullType = initType(JavaType.BOT, "<nulltype>");
    voidType = initType(JavaType.VOID, "void");

    bytecodeCompleter.init(this);

    // predefined types for java lang
    JavaSymbol.PackageJavaSymbol javalang = bytecodeCompleter.enterPackage("java.lang");
    // define a star import scope to let resolve types to java.lang when needed.
    javalang.members = new Scope.StarImportScope(javalang, bytecodeCompleter);
    javalang.members.enter(javalang);

    objectType = bytecodeCompleter.loadClass("java.lang.Object").type;
    classType = bytecodeCompleter.loadClass("java.lang.Class").type;
    stringType = bytecodeCompleter.loadClass("java.lang.String").type;
    cloneableType = bytecodeCompleter.loadClass("java.lang.Cloneable").type;
    serializableType = bytecodeCompleter.loadClass("java.io.Serializable").type;
    annotationType = bytecodeCompleter.loadClass("java.lang.annotation.Annotation").type;
    enumType = bytecodeCompleter.loadClass("java.lang.Enum").type;

    // Associate boxed types
    boxedTypes = HashBiMap.create();
    boxedTypes.put(byteType, bytecodeCompleter.loadClass("java.lang.Byte").type);
    boxedTypes.put(charType, bytecodeCompleter.loadClass("java.lang.Character").type);
    boxedTypes.put(shortType, bytecodeCompleter.loadClass("java.lang.Short").type);
    boxedTypes.put(intType, bytecodeCompleter.loadClass("java.lang.Integer").type);
    boxedTypes.put(longType, bytecodeCompleter.loadClass("java.lang.Long").type);
    boxedTypes.put(floatType, bytecodeCompleter.loadClass("java.lang.Float").type);
    boxedTypes.put(doubleType, bytecodeCompleter.loadClass("java.lang.Double").type);
    boxedTypes.put(booleanType, bytecodeCompleter.loadClass("java.lang.Boolean").type);

    for (Entry<JavaType, JavaType> entry : boxedTypes.entrySet()) {
      entry.getKey().primitiveWrapperType = entry.getValue();
      entry.getValue().primitiveType = entry.getKey();
    }

    // TODO comment me
    arrayClass = new JavaSymbol.TypeJavaSymbol(Flags.PUBLIC, "Array", noSymbol);
    JavaType.ClassJavaType arrayClassType = (JavaType.ClassJavaType) arrayClass.type;
    arrayClassType.supertype = objectType;
    arrayClassType.interfaces = ImmutableList.of(cloneableType, serializableType);
    arrayClass.members = new Scope(arrayClass);
    arrayClass
        .members()
        .enter(
            new JavaSymbol.VariableJavaSymbol(
                Flags.PUBLIC | Flags.FINAL, "length", intType, arrayClass));
    // TODO arrayClass implements clone() method

    enterOperators();
  }
  public void update() {
    Lifecycle serverState = getAttribute(Attributes.SERVICE_STATE_ACTUAL);
    if (Lifecycle.STOPPED.equals(serverState)
        || Lifecycle.STOPPING.equals(serverState)
        || Lifecycle.DESTROYED.equals(serverState)
        || !getAttribute(Attributes.SERVICE_UP)) {
      LOG.debug(
          "Skipped update of {} when service state is {} and running is {}",
          new Object[] {
            this, getAttribute(Attributes.SERVICE_STATE_ACTUAL), getAttribute(SERVICE_UP)
          });
      return;
    }
    synchronized (this) {
      Iterable<Entity> availableEntities =
          FluentIterable.from(getEntities().getMembers())
              .filter(new HasHostnameAndValidLifecycle());
      LOG.debug("{} updating with entities: {}", this, Iterables.toString(availableEntities));
      ImmutableListMultimap<String, Entity> hostnameToEntity =
          Multimaps.index(availableEntities, new HostnameTransformer());

      Map<String, String> octetToName = Maps.newHashMap();
      BiMap<String, String> ipToARecord = HashBiMap.create();
      Multimap<String, String> aRecordToCnames = MultimapBuilder.hashKeys().hashSetValues().build();
      Multimap<String, String> ipToAllNames = MultimapBuilder.hashKeys().hashSetValues().build();

      for (Map.Entry<String, Entity> e : hostnameToEntity.entries()) {
        String domainName = e.getKey();
        Maybe<SshMachineLocation> location =
            Machines.findUniqueSshMachineLocation(e.getValue().getLocations());
        if (!location.isPresent()) {
          LOG.debug(
              "Member {} of {} does not have an SSH location so will not be configured",
              e.getValue(),
              this);
          continue;
        } else if (ipToARecord.inverse().containsKey(domainName)) {
          continue;
        }

        String address = location.get().getAddress().getHostAddress();
        ipToAllNames.put(address, domainName);
        if (!ipToARecord.containsKey(address)) {
          ipToARecord.put(address, domainName);
          if (getReverseLookupNetwork().contains(new Cidr(address + "/32"))) {
            String octet = Iterables.get(Splitter.on('.').split(address), 3);
            if (!octetToName.containsKey(octet)) octetToName.put(octet, domainName);
          }
        } else {
          aRecordToCnames.put(ipToARecord.get(address), domainName);
        }
      }
      setAttribute(A_RECORDS, ImmutableMap.copyOf(ipToARecord.inverse()));
      setAttribute(PTR_RECORDS, ImmutableMap.copyOf(octetToName));
      setAttribute(CNAME_RECORDS, Multimaps.unmodifiableMultimap(aRecordToCnames));
      setAttribute(ADDRESS_MAPPINGS, Multimaps.unmodifiableMultimap(ipToAllNames));

      // Update Bind configuration files and restart the service
      getDriver().updateBindConfiguration();
    }
  }