Java Code Examples for java.util.TreeMap

public ActionForward viewAttends(ActionMapping mapping, ActionForm actionForm, HttpServletRequest request,
        HttpServletResponse response) {
    RenderUtils.invalidateViewState();

    final Registration registration = getAndSetRegistration(request);
    request.setAttribute("registration", registration);

    if (registration != null) {
        final SortedMap<ExecutionSemester, SortedSet<Attends>> attendsMap =
                new TreeMap<ExecutionSemester, SortedSet<Attends>>();
        for (final Attends attends : registration.getAssociatedAttendsSet()) {
            final ExecutionSemester executionSemester = attends.getExecutionPeriod();
            SortedSet<Attends> attendsSet = attendsMap.get(executionSemester);
            if (attendsSet == null) {
                attendsSet = new TreeSet<Attends>(Attends.ATTENDS_COMPARATOR);
                attendsMap.put(executionSemester, attendsSet);
            }
            attendsSet.add(attends);
        }
        request.setAttribute("attendsMap", attendsMap);
    }

    return mapping.findForward("viewAttends");
}
 

/**
 * Read a map of {@code int} to {@code Type} from an input stream. This is used to store deoptimization state.
 *
 * @param input data input
 * @return type map
 * @throws IOException if read cannot be completed
 */
public static Map<Integer, Type> readTypeMap(final DataInput input) throws IOException {
    final int size = input.readInt();
    if (size <= 0) {
        return null;
    }
    final Map<Integer, Type> map = new TreeMap<>();
    for(int i = 0; i < size; ++i) {
        final int pp = input.readInt();
        final int typeChar = input.readByte();
        final Type type;
        switch (typeChar) {
            case 'L': type = Type.OBJECT; break;
            case 'D': type = Type.NUMBER; break;
            case 'J': type = Type.LONG; break;
            default: continue;
        }
        map.put(pp, type);
    }
    return map;
}
 

/**
 * 创建每个三角形的共享边列表 Creates a map over each triangle and its Edge connections to
 * other triangles. Each edge must follow the vertex winding order of the
 * triangle associated with it. Since all triangles are assumed to have the same
 * winding order, this means if two triangles connect, each must have its own
 * edge connection data, where the edge follows the same winding order as the
 * triangle which owns the edge data.
 *
 * @param indexConnections
 * @param triangles
 * @param vertexVectors
 * @return
 */
private static Map<Triangle, List<TriangleEdge>> createSharedEdgesMap(Set<IndexConnection> indexConnections,
		List<Triangle> triangles, List<Vector3> vertexVectors) {

	Map<Triangle, List<TriangleEdge>> connectionMap = new TreeMap<Triangle, List<TriangleEdge>>(
			(o1, o2) -> o1.getIndex() - o2.getIndex());
	// connectionMap.ordered = true;

	for (Triangle tri : triangles) {
		connectionMap.put(tri, new ArrayList<TriangleEdge>());
	}

	for (IndexConnection indexConnection : indexConnections) {
		Triangle fromNode = triangles.get(indexConnection.fromTriIndex);
		Triangle toNode = triangles.get(indexConnection.toTriIndex);
		Vector3 edgeVertexA = vertexVectors.get(indexConnection.edgeVertexIndex1);
		Vector3 edgeVertexB = vertexVectors.get(indexConnection.edgeVertexIndex2);

		TriangleEdge edge = new TriangleEdge(fromNode, toNode, edgeVertexA, edgeVertexB);
		connectionMap.get(fromNode).add(edge);
		fromNode.connections.add(edge);
		// LOGGER.debug("三角形：{} -->{}
		// {}-->{}",fromNode.getIndex(),toNode.getIndex(),fromNode.toString(),toNode.toString());
	}
	return connectionMap;
}
 

public static int getRequiredRoomsAmount(Interval[] intervals) {
    Map<Integer, Integer> map = new TreeMap<>();

    for (Interval interval : intervals) {
        map.put(interval.start, map.getOrDefault(interval.start, 0) + 1);
        map.put(interval.end, map.getOrDefault(interval.end, 0) - 1);
    }

    int res = 0;
    int count = 0;

    for (int delta : map.values())
        res = Math.max(res, count += delta);

    return res;
}
 

static <V> Map<String, V> loadFromProperties(Path path, Function<String, V> valueFactory) {
  LOG.log(DEBUG, "Loading properties from `%s`...", path);
  var map = new TreeMap<String, V>();
  if (Files.notExists(path)) {
    return map;
  }
  try (var lines = Files.lines(path)) {
    lines
        .map(String::trim)
        .filter(not(String::isEmpty))
        .filter(line -> line.charAt(0) != '#')
        .forEach(
            line -> {
              var values = line.split("=");
              var key = values[0].trim();
              var value = valueFactory.apply(values[1].trim());
              if (map.put(key, value) != null) {
                throw new IllegalStateException("Duplicate key found: " + key);
              }
            });
  } catch (IOException e) {
    throw new UncheckedIOException("Loading properties failed for: " + path, e);
  }
  LOG.log(DEBUG, "Loaded {0} properties from: {1}", map.size(), path);
  return map;
}
 

public String doRoute(String serviceKey, TreeSet<String> addressSet) {

        // ------A1------A2-------A3------
        // -----------J1------------------
        TreeMap<Long, String> addressRing = new TreeMap<Long, String>();
        for (String address: addressSet) {
            for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
                long addressHash = hash("SHARD-" + address + "-NODE-" + i);
                addressRing.put(addressHash, address);
            }
        }

        long jobHash = hash(serviceKey);
        SortedMap<Long, String> lastRing = addressRing.tailMap(jobHash);
        if (!lastRing.isEmpty()) {
            return lastRing.get(lastRing.firstKey());
        }
        return addressRing.firstEntry().getValue();
    }
 

@Test public void treeMapEntryTest() {
    TreeMap<String,Integer> control = new TreeMap<>();
    control.put("one", 1);
    Map.Entry<String,Integer> realEntry = control.entrySet().iterator().next();
    Tuple2<String,Integer> test = Tuple2.of("one", 1);

    assertEquals(realEntry.hashCode(), test.hashCode());

    assertEquals(realEntry.hashCode(), serializeDeserialize(test).hashCode());

    assertTrue(test.equals(realEntry));
    assertTrue(realEntry.equals(test));

    assertTrue(serializeDeserialize(test).equals(realEntry));
    assertTrue(realEntry.equals(serializeDeserialize(test)));
}
 

public static DynamicEntityMeta createDynamicEntityMetaForMultiReference(AdmCiTypeAttr multiSelAttr) {
    DynamicEntityMeta meta = new DynamicEntityMeta();
    AdmCiType ciType = multiSelAttr.getAdmCiType();
    meta.setType(DynamicEntityType.MultiRefIntermedia);
    String intermediaTableName = multiSelAttr.retrieveJoinTalbeName();
    meta.setQulifiedName(DynamicEntityUtils.getEntityQuanlifiedName(intermediaTableName));
    meta.setTableName(intermediaTableName);
    meta.setCiTypeId(ciType.getIdAdmCiType());

    SortedMap<String, FieldNode> fieldNodeMap = new TreeMap<String, FieldNode>();
    FieldNode fieldNode = new FieldNode(DynamicEntityType.MultiRefIntermedia, null, "id", Integer.class, "id", true);
    fieldNodeMap.put("id", fieldNode);

    fieldNode = new FieldNode(DynamicEntityType.MultiSelIntermedia, null, "from_guid", String.class, "from_guid");
    fieldNodeMap.put("from_guid", fieldNode);

    fieldNode = new FieldNode(DynamicEntityType.MultiSelIntermedia, null, "to_guid", String.class, "to_guid");
    fieldNodeMap.put("to_guid", fieldNode);

    fieldNode = new FieldNode(DynamicEntityType.MultiSelIntermedia, null, "seq_no", Integer.class, "seq_no");
    fieldNodeMap.put("seq_no", fieldNode);
    meta.setFieldMap(fieldNodeMap);
    return meta;
}
 

/**
 * Get the thread list with CPU consumption and the ThreadInfo
 * for each thread sorted by the CPU time.
 */
private List<Map.Entry<Long, ThreadInfo>> getThreadList() {
    // Get all threads and their ThreadInfo objects
    // with no stack trace
    long[] tids = tmbean.getAllThreadIds();
    ThreadInfo[] tinfos = tmbean.getThreadInfo(tids);

    // build a map with key = CPU time and value = ThreadInfo
    SortedMap<Long, ThreadInfo> map = new TreeMap<Long, ThreadInfo>();
    for (int i = 0; i < tids.length; i++) {
        long cpuTime = tmbean.getThreadCpuTime(tids[i]);
        // filter out threads that have been terminated
        if (cpuTime != -1 && tinfos[i] != null) {
            map.put(new Long(cpuTime), tinfos[i]);
        }
    }

    // build the thread list and sort it with CPU time
    // in decreasing order
    Set<Map.Entry<Long, ThreadInfo>> set = map.entrySet();
    List<Map.Entry<Long, ThreadInfo>> list =
        new ArrayList<Map.Entry<Long, ThreadInfo>>(set);
    Collections.reverse(list);
    return list;
}
 

@Override
@SuppressWarnings("unchecked")
public <K, V> List<V> getMultimapValues(String id, K multimapKey) {
	if (this.temporaryData == null) {
		this.temporaryData = new TreeMap<>();
	}
	Map<K, List<V>> multimap = (Map<K, List<V>>) this.temporaryData.get(id);
	if (multimap == null) {
		multimap = new HashMap<>();
		this.temporaryData.put(id, multimap);
	}
	List<V> list = multimap.get(multimapKey);
	if (list == null) {
		list = new ArrayList<>();
		multimap.put(multimapKey, list);
	}
	return list;
}
 

/**
 * descendingEntrySet contains all pairs
 */
public void testDescendingEntrySet() {
    TreeMap map = map5();
    Set s = map.descendingMap().entrySet();
    assertEquals(5, s.size());
    Iterator it = s.iterator();
    while (it.hasNext()) {
        Map.Entry e = (Map.Entry) it.next();
        assertTrue(
                   (e.getKey().equals(one) && e.getValue().equals("A")) ||
                   (e.getKey().equals(two) && e.getValue().equals("B")) ||
                   (e.getKey().equals(three) && e.getValue().equals("C")) ||
                   (e.getKey().equals(four) && e.getValue().equals("D")) ||
                   (e.getKey().equals(five) && e.getValue().equals("E")));
    }
}
 

@Override
public RegionLocator getRegionLocator(TableName tableName) throws IOException {
  final Map<byte[], HRegionLocation> locationMap = new TreeMap<>(Bytes.BYTES_COMPARATOR);
  for (byte[] startKey : START_KEYS) {
    HRegionLocation hrl = new HRegionLocation(
        RegionInfoBuilder.newBuilder(tableName).setStartKey(startKey).build(),
        ServerName.valueOf("localhost", 0, 0));
    locationMap.put(startKey, hrl);
  }

  RegionLocator locator = mock(RegionLocator.class);
  when(locator.getRegionLocation(any(byte [].class), anyBoolean())).
    thenAnswer(new Answer<HRegionLocation>() {
      @Override
      public HRegionLocation answer(InvocationOnMock invocationOnMock) throws Throwable {
        Object [] args = invocationOnMock.getArguments();
        byte [] key = (byte [])args[0];
        return locationMap.get(key);
      }
    });
  when(locator.getStartEndKeys()).
    thenReturn(new Pair<byte[][], byte[][]>(START_KEYS, END_KEYS));
  return locator;
}
 

public static SparseVector sparse(Vector V) {
	if (V instanceof DenseVector) {
		double[] values = ((DenseVector) V).getPr();
		TreeMap<Integer, Double> map = new TreeMap<Integer, Double>();
		for (int k = 0; k < values.length; k++) {
			if (values[k] != 0) {
				map.put(k, values[k]);
			}
		}
		int nnz = map.size();
		int[] ir = new int[nnz];
		double[] pr = new double[nnz];
		int dim = values.length;
		int ind = 0;
		for (Entry<Integer, Double> entry : map.entrySet()) {
			ir[ind] = entry.getKey();
			pr[ind] = entry.getValue();
			ind++;
		}
		return new SparseVector(ir, pr, nnz, dim);
	} else {
		return (SparseVector) V;
	}
}
 

/**
 * 下单接口
 * 
 * @param coinType
 * @param price
 * @param amount
 * @param tradePassword
 * @param tradeid
 * @param method
 * @return
 * @throws Exception
 */
public String buy(int coinType, String price, String amount, String tradePassword, Integer tradeid, String method)
		throws Exception {
	TreeMap<String, Object> paraMap = new TreeMap<String, Object>();
	paraMap.put("method", method);
	paraMap.put("created", getTimestamp());
	paraMap.put("access_key", huobiAccessKey);
	paraMap.put("secret_key", huobiSecretKey);
	paraMap.put("coin_type", coinType);
	paraMap.put("price", price);
	paraMap.put("amount", amount);
	String md5 = sign(paraMap);
	paraMap.remove("secret_key");
	paraMap.put("sign", md5);
	if (StringUtils.isNotEmpty(tradePassword)) {
		paraMap.put("trade_password", tradePassword);
	}
	if (null != tradeid) {
		paraMap.put("trade_id", tradeid);
	}
	return post(paraMap, huobiApiUrl);
}
 

@Override
public void update(NoteEvent noteEvent) {
  StringBuilder sb = new StringBuilder();
  NotableTableModel model = noteEvent.getSource();
  TreeMap<Integer, Note> allNotes = model.getAllNotes();
  for (Integer idx : allNotes.keySet()) {
    Note note = allNotes.get(idx);
    sb.append(idx).append(": ").append(note.getNote());
    sb.append('\n');
  }
  if (sb.length() == 0) {
    sb.append("No notes.");
  }
  allNotesTextArea.setText(sb.toString());

}
 

private FileSystemPreferences(FileSystemPreferences parent, String name) {
    super(parent, name);
    isUserNode = parent.isUserNode;
    dir  = new File(parent.dir, dirName(name));
    prefsFile = new File(dir, "prefs.xml");
    tmpFile  = new File(dir, "prefs.tmp");
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            newNode = !dir.exists();
            return null;
        }
    });
    if (newNode) {

        prefsCache = new TreeMap<String, String>();
        nodeCreate = new NodeCreate();
        changeLog.add(nodeCreate);
    }
}
 

/**
 * Returns an immutable map containing each field to its list of values. The
 * status line is mapped to null.
 */
public Map<String, List<String>> toMultimap(boolean response) {
  Map<String, List<String>> result = new TreeMap<String, List<String>>(FIELD_NAME_COMPARATOR);
  for (int i = 0; i < namesAndValues.size(); i += 2) {
    String fieldName = namesAndValues.get(i);
    String value = namesAndValues.get(i + 1);

    List<String> allValues = new ArrayList<String>();
    List<String> otherValues = result.get(fieldName);
    if (otherValues != null) {
      allValues.addAll(otherValues);
    }
    allValues.add(value);
    result.put(fieldName, Collections.unmodifiableList(allValues));
  }
  if (response && statusLine != null) {
    result.put(null, Collections.unmodifiableList(Collections.singletonList(statusLine)));
  } else if (requestLine != null) {
    result.put(null, Collections.unmodifiableList(Collections.singletonList(requestLine)));
  }
  return Collections.unmodifiableMap(result);
}
 

/**
 * Returns a java.util.Map containing all of the entrys in this object. If
 * an entry in the object is a JSONArray or JSONObject it will also be
 * converted.
 * <p>
 * Warning: This method assumes that the data structure is acyclical.
 *
 * @return a java.util.Map containing the entrys of this object
 */
public Map<String, Object> toMap() {
	Map<String, Object> results = new TreeMap<String, Object>();
	for (Entry<String, Object> entry : this.map.entrySet()) {
		Object value;
		if (entry.getValue() == null || NULL.equals(entry.getValue())) {
			value = null;
		} else if (entry.getValue() instanceof JSONObject) {
			value = ((JSONObject) entry.getValue()).toMap();
		} else if (entry.getValue() instanceof JSONArray) {
			value = ((JSONArray) entry.getValue()).toList();
		} else {
			value = entry.getValue();
		}
		results.put(entry.getKey(), value);
	}
	return results;
}
 

@Override
public ArrayData shiftRight(final int by) {
    final TreeMap<Long, Object> newSparseMap = new TreeMap<>();
    final long len = underlying.length();
    if (len + by > maxDenseLength) {
        for (long i = maxDenseLength - by; i < len; i++) {
            if (underlying.has((int) i)) {
                newSparseMap.put(Long.valueOf(i + by), underlying.getObject((int) i));
            }
        }
        underlying = underlying.shrink((int) (maxDenseLength - by));
    }

    underlying.shiftRight(by);

    for (final Map.Entry<Long, Object> entry : sparseMap.entrySet()) {
        final long newIndex = entry.getKey().longValue() + by;
        newSparseMap.put(Long.valueOf(newIndex), entry.getValue());
    }

    sparseMap = newSparseMap;
    setLength(length() + by);

    return this;
}
 

@DataProvider(name="maps")
static Object[][] mapCases() {
    if (collections != null) {
        return collections;
    }

    List<Object[]> cases = new ArrayList<>();
    for (int size : new int[] {1, 2, 16}) {
        cases.add(new Object[] {
                String.format("new HashMap(%d)", size),
                (Supplier<Map<Integer, Integer>>)
                () -> Collections.unmodifiableMap(fillMap(size, new HashMap<>())) });
        cases.add(new Object[] {
                String.format("new TreeMap(%d)", size),
                (Supplier<Map<Integer, Integer>>)
                () -> Collections.unmodifiableSortedMap(fillMap(size, new TreeMap<>())) });
    }

    return cases.toArray(new Object[0][]);
}
 

/**
 * 取得带相同前缀的Request Parameters.
 * 
 * 返回的结果的Parameter名已去除前缀.
 */
public static Map<String, Object> getParametersStartingWith(ServletRequest request, String prefix) {
	AssertUtils.notNull(request, "Request must not be null");
	Enumeration paramNames = request.getParameterNames();
	Map<String, Object> params = new TreeMap<String, Object>();
	if (prefix == null) {
		prefix = "";
	}
	while (paramNames != null && paramNames.hasMoreElements()) {
		String paramName = (String) paramNames.nextElement();
		if ("".equals(prefix) || paramName.startsWith(prefix)) {
			String unprefixed = paramName.substring(prefix.length());
			String[] values = request.getParameterValues(paramName);
			if (values == null || values.length == 0) {
				// Do nothing, no values found at all.
			} else if (values.length > 1) {
				params.put(unprefixed, values);
			} else {
				params.put(unprefixed, values[0]);
			}
		}
	}
	return params;
}
 

/** Apply mapping on a given map.
 * Map keys are renamed, and those missing are removed
 * 
 * @param src Map to be processed.
 * @param mapping Mapping according to which to process src
 * @return
 */
static <T> TreeMap<String, T> applyResultMapping(SortedMap<String, T> src, SortedMap<String, String> mapping) {
    if (src == null) {
        return null;
    }
    final TreeMap<String, T> result = new TreeMap<String, T>();
    for (SortedMap.Entry<String, T> entry : src.entrySet()) {
        final String newName = mapping.get(entry.getKey());
        if (newName != null) {
            result.put(newName, entry.getValue());
        }
    }
    return result;
}
 

private Map<String, RESTCommand> getCmdNameMap(String cmdOwner) {
    SortedMap<String, RESTCommand> cmdNameMap = m_cmdsByOwnerMap.get(cmdOwner);
    if (cmdNameMap == null) {
        cmdNameMap = new TreeMap<>();
        m_cmdsByOwnerMap.put(cmdOwner, cmdNameMap);
    }
    return cmdNameMap;
}
 

private String getSignature(RequestMessage request) throws ClientException {
    Map<String, String> headers = request.getHeaders();

    StringBuffer canonicalizedHeaders = new StringBuffer();
    StringBuffer stringToSign = new StringBuffer();
    String contentMd5 = safeGetHeader(Constants.CONTENT_MD5, headers);
    String contentType = safeGetHeader(Constants.CONTENT_TYPE, headers);
    String date = safeGetHeader(Constants.DATE, headers);
    String canonicalizedResource = getRelativeResourcePath(request
            .getResourcePath());

    TreeMap<String, String> tmpHeaders = sortHeader(request.getHeaders());
    if (tmpHeaders.size() > 0) {
        Set<String> keySet = tmpHeaders.keySet();
        for (String key : keySet) {
            if (key.toLowerCase().startsWith(
                    Constants.X_HEADER_PREFIX)) {
                canonicalizedHeaders.append(key).append(":")
                        .append(tmpHeaders.get(key)).append("\n");
            }
        }
    }
    stringToSign.append(method).append("\n").append(contentMd5)
            .append("\n").append(contentType).append("\n").append(date)
            .append("\n").append(canonicalizedHeaders)
            .append(canonicalizedResource);
    String signature;

    try {
        signature = ServiceSignature.create().computeSignature(
                credentials.getAccessKeySecret(), stringToSign.toString());
    } catch (Exception e) {
        throw new ClientException("Signature fail", null, e);
    }

    return signature;
}
 

private SortedMap<String, File> mapFiles(final List<File> files) {

        final SortedMap<String, File> toReturn = new TreeMap<String, File>();
        for (File current : files) {
            toReturn.put(current.getPath(), current);
        }

        return toReturn;
    }
 

protected void groupByDateSessions(List<Session> sessions) {
    Map<String, List<Session>> sessionsByDate = new TreeMap<>();
    for (Session session : sessions) {
        String key = DateUtil.getMonthDate(session.stime, getActivity());
        if (sessionsByDate.containsKey(key)) {
            sessionsByDate.get(key).add(session);
        } else {
            List<Session> list = new ArrayList<>();
            list.add(session);
            sessionsByDate.put(key, list);
        }
    }

    adapter = new SessionsPagerAdapter(getFragmentManager());

    for (Map.Entry<String, List<Session>> e : sessionsByDate.entrySet()) {
        addFragment(e.getKey(), e.getValue());
    }

    binding.viewPager.setAdapter(adapter);
    binding.tabLayout.setupWithViewPager(binding.viewPager);
    binding.tabLayout.setOnTabSelectedListener(new CustomViewPagerOnTabSelectedListener(binding.viewPager));

    hideLoadingView();
    if (sessions.isEmpty()) {
        showEmptyView();
    } else {
        hideEmptyView();
    }
}
 

public static NavigableMap<String, Path> getPorts(Path path)
		throws IOException {
	NavigableMap<String, Path> ports = new TreeMap<>();
	try (DirectoryStream<Path> ds = newDirectoryStream(path)) {
		for (Path p : ds)
			ports.put(filenameWithoutExtension(p), p);
	}
	return ports;
}
 

/**
 * Log the known issue.
 * This method returns true unless -prop:logKnownIssue=no is specified
 * in the argument list.
 *
 * @param ticket A ticket number string. For an ICU ticket, use numeric characters only,
 * such as "10245". For a CLDR ticket, use prefix "cldrbug:" followed by ticket number,
 * such as "cldrbug:5013".
 * @param comment Additional comment, or null
 * @return true unless -prop:logKnownIssue=no is specified in the test command line argument.
 */
protected static boolean logKnownIssue(String ticket, String comment) {
    if (!getBooleanProperty("logKnownIssue", true)) {
        return false;
    }

    StringBuffer descBuf = new StringBuffer();
    // TODO(junit) : what to do about this?
    //getParams().stack.appendPath(descBuf);
    if (comment != null && comment.length() > 0) {
        descBuf.append(" (" + comment + ")");
    }
    String description = descBuf.toString();

    String ticketLink = "Unknown Ticket";
    if (ticket != null && ticket.length() > 0) {
        boolean isCldr = false;
        ticket = ticket.toLowerCase(Locale.ENGLISH);
        if (ticket.startsWith(CLDR_TICKET_PREFIX)) {
            isCldr = true;
            ticket = ticket.substring(CLDR_TICKET_PREFIX.length());
        }
        ticketLink = (isCldr ? CLDR_TRAC_URL : ICU_TRAC_URL) + ticket;
    }

    if (getParams().knownIssues == null) {
        getParams().knownIssues = new TreeMap<String, List<String>>();
    }
    List<String> lines = getParams().knownIssues.get(ticketLink);
    if (lines == null) {
        lines = new ArrayList<String>();
        getParams().knownIssues.put(ticketLink, lines);
    }
    if (!lines.contains(description)) {
        lines.add(description);
    }

    return true;
}
 

@Test
public void setRowAttrsTest() {
    Map<String, Object> attrsMap = new TreeMap<>();
    attrsMap.put("quote", "\"Don't worry, be happy\"");
    attrsMap.put("active", true);
    PqlQuery q = collabField.setRowAttrs(5, attrsMap);
    assertEquals(
            "SetRowAttrs(collaboration,5,active=true,quote=\"\\\"Don't worry, be happy\\\"\")",
            q.serialize().getQuery());
    q = collabField.setRowAttrs("foo", attrsMap);
    assertEquals(
            "SetRowAttrs('collaboration','foo',active=true,quote=\"\\\"Don't worry, be happy\\\"\")",
            q.serialize().getQuery());
}
 

public StreamSegments withReplacementRange(Segment segment, StreamSegmentsWithPredecessors replacementRanges) {
    SegmentWithRange replacedSegment = findReplacedSegment(segment);
    verifyReplacementRange(replacedSegment, replacementRanges);
    NavigableMap<Double, SegmentWithRange> result = new TreeMap<>();
    Map<Long, List<SegmentWithRange>> replacedRanges = replacementRanges.getReplacementRanges();
    List<SegmentWithRange> replacements = replacedRanges.get(segment.getSegmentId());
    Preconditions.checkNotNull(replacements, "Empty set of replacements for: {}", segment.getSegmentId());
    replacements.sort(Comparator.comparingDouble((SegmentWithRange s) -> s.getRange().getHigh()).reversed());
    verifyContinuous(replacements);
    for (Entry<Double, SegmentWithRange> existingEntry : segments.descendingMap().entrySet()) { // iterate from the highest key.
        final SegmentWithRange existingSegment = existingEntry.getValue();
        if (existingSegment.equals(replacedSegment)) { // Segment needs to be replaced.
            // Invariant: The successor segment(s)'s range should be limited to the replaced segment's range, thereby
            // ensuring that newer writes to the successor(s) happen only for the replaced segment's range.
            for (SegmentWithRange segmentWithRange : replacements) {
                Double lowerBound = segments.lowerKey(existingEntry.getKey()); // Used to skip over items not in the clients view yet.
                if (lowerBound == null || segmentWithRange.getRange().getHigh() >= lowerBound) { 
                    result.put(Math.min(segmentWithRange.getRange().getHigh(), existingEntry.getKey()), segmentWithRange);
                }
            }
        } else {
            // update remaining values.
            result.put(existingEntry.getKey(), existingEntry.getValue());
        }
    }
    removeDuplicates(result);
    return new StreamSegments(result, delegationToken);
}