import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
String makeMassiveString() {
  int numCodePoints = 1 << 19;
  StringBuilder b = new StringBuilder(
      // Overestimate.
      numCodePoints * 2);
  int nextCp = 0;
  for (int i = 0; i < numCodePoints; i++) {
    b.appendCodePoint(nextCp);
    if (i + 1 < numCodePoints && i % 80 == 79) {
      b.append("\n");
      i++;
    }
    nextCp = (nextCp + 1) & 0x10ffff;
    while (Utf16Util.isSurrogate(nextCp) || !Utf16Util.isCodePointValid(nextCp)) {
      //log.info("Skipping cp " + nextCp);
      nextCp = (nextCp + 1) & 0x10ffff;
    }
  }
  return "" + b;
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
@VisibleForTesting
Item getTextChunk() throws XmlParseException {
  StringBuffer b = new StringBuffer();
  while (true) {
    String c = charData();
    if (c != null) {
      b.append(c);
      continue;
    }
    String r = reference();
    if (r != null) {
      b.append(r);
      continue;
    }
    if (b.length() > 0) {
      String val = b.toString();
      // Ensure that the sequence of character references form valid UTF-16
      ensure(Utf16Util.isValidUtf16(val), "Not valid UTF-16: " + val);
      return Item.text(val);
    } else {
      return null;
    }
  }
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private ValidationResult checkAttributesUpdateWellFormed(AttributesUpdate u,
    ViolationCollector v) {
  if (u == null) { return nullAttributesUpdate(v); }
  String previousKey = null;
  for (int i = 0; i < u.changeSize(); i++) {
    String key = u.getChangeKey(i);
    if (key == null) { return nullAttributeKey(v); }
    if (!Utf16Util.isXmlName(key)) { return attributeNameNotXmlName(v, key); }
    if (previousKey != null && previousKey.compareTo(key) >= 0) {
      return attributeKeysNotStrictlyMonotonic(v, previousKey, key);
    }
    if (u.getOldValue(i) != null && !Utf16Util.isValidUtf16(u.getOldValue(i))) {
      return attributeValueNotValidUtf16(v);
    }
    if (u.getNewValue(i) != null && !Utf16Util.isValidUtf16(u.getNewValue(i))) {
      return attributeValueNotValidUtf16(v);
    }
    previousKey = key;
  }
  return ValidationResult.VALID;
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
public ValidationResult checkDeleteCharacters(String chars, ViolationCollector v) {
  // well-formedness
  if (chars == null) { return nullCharacters(v); }
  if (chars.isEmpty()) { return emptyCharacters(v); }
  if (Utf16Util.firstSurrogate(chars) != -1) { return deleteCharactersContainsSurrogate(v); }
  if (!Utf16Util.isValidUtf16(chars)) { return deleteCharactersInvalidUnicode(v); }
  if (!insertionStackIsEmpty()) { return deleteInsideInsert(v); }
  // validity
  int docLength = doc.length();
  for (int offset = 0; offset < chars.length(); offset++) {
    if (effectivePos + offset >= docLength) {
      return cannotDeleteSoManyCharacters(v, offset, chars);
    }
    int charHereIfAny = doc.charAt(effectivePos + offset);
    if (charHereIfAny == -1) {
      return cannotDeleteSoManyCharacters(v, offset, chars);
    }
    char charHere = (char) charHereIfAny;
    if (charHere != chars.charAt(offset)) {
      return oldCharacterDiffersFromDocument(v, charHere, chars.charAt(offset));
    }
  }
  return checkAnnotationsForDeletion(v, chars.length());
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
/**
 * Extracts code points from a given character string.
 *
 * @param chars a character string from which to extract code points
 * @return the code points extracted from the given string
 */
private static List<Integer> extractCodePoints(String chars) throws InvalidSchemaException {
  List<Integer> codePoints = Utf16Util.traverseUtf16String(chars, codePointExtractor);
  if (codePoints == ERROR_LIST) {
    throw new InvalidSchemaException("Invalid code point in string: " + chars);
  }
  return codePoints;
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
@Override
public Boolean codePoint(int cp) {
  if (!Utf16Util.isCodePointValid(cp)) {
    return false;
  }
  if (cp < SAFE_ASCII_CHARS.length && !SAFE_ASCII_CHARS[cp]) {
    return false;
  }
  if (cp >= SAFE_ASCII_CHARS.length && !isUcsChar(cp)) {
    return false;
  }
  return null;
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private void advanceCodePoint() {
  if (Utf16Util.isHighSurrogate(str.charAt(position))) {
    position += 2;
  } else {
    position++;
  }
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
StreamingXmlParser(String xml) throws XmlParseException {
  // Ensure that the input is valid UTF-16 here, makes rest of the code
  // simpler
  if (Utf16Util.isValidUtf16(xml)) {
    buffer = new Buffer(xml);
  } else {
    throw new XmlParseException("Input is not valid UTF-16: " + xml);
  }
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private boolean isXmlNameStartChar(int codePoint) throws XmlParseException {
  try {
    return Utf16Util.isXmlNameStartChar(codePoint);
  } catch (RuntimeException e) {
    throw new XmlParseException(e);
  }
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private boolean isXmlNameChar(int codePoint) throws XmlParseException {
  try {
    return Utf16Util.isXmlNameChar(codePoint);
  } catch (RuntimeException e) {
    throw new XmlParseException(e);
  }
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
@VisibleForTesting
String charReference() throws XmlParseException {
  if (match(charReferenceStart)) {
    final int base;
    final ReadableStringSet validDigits;
    if (match('x')) {
      base = 16;
      validDigits = BASE_16_DIGITS;
    } else {
      base = 10;
      validDigits = BASE_10_DIGITS;
    }
    final int start = buffer.getPosition();
    while (validDigits.contains("" + (char) buffer.peek())) {
      buffer.advanceCodeUnit(1);
    }
    final int end = buffer.getPosition();
    ensure(start != end, "empty char reference");
    final int codePoint;
    final String number = buffer.substring(start, end);
    try {
      codePoint = Integer.parseInt(number, base);
    } catch (NumberFormatException e) {
      throw new XmlParseException("Could not parse number: " + number, e);
    }
    ensure(Utf16Util.isCodePoint(codePoint), "Not a codepoint: " + (base == 16 ? "0x" : "")
        + number);
    String ret = String.valueOf(Character.toChars(codePoint));
    ensure(match(';'), "Must match ; at end of charReference");
    return ret;
  }
  return null;
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private ValidationResult checkAttributesWellFormed(Attributes attr, ViolationCollector v) {
  if (attr == null) { return nullAttributes(v); }
  String previousKey = null;
  for (Map.Entry<String, String> e : attr.entrySet()) {
    if (e.getKey() == null) { return nullAttributeKey(v); }
    if (!Utf16Util.isXmlName(e.getKey())) { return attributeNameNotXmlName(v, e.getKey()); }
    if (e.getValue() == null) { return nullAttributeValue(v); }
    if (!Utf16Util.isValidUtf16(e.getValue())) { return attributeValueNotValidUtf16(v); }
    if (previousKey != null && previousKey.compareTo(e.getKey()) >= 0) {
      return attributeKeysNotStrictlyMonotonic(v, previousKey, e.getKey());
    }
    previousKey = e.getKey();
  }
  return ValidationResult.VALID;
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private static void checkElementType(String name) throws InvalidSchemaException {
  if (!Utf16Util.isXmlName(name)) {
    throw new InvalidSchemaException("Invalid element type: " + name);
  }
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private static void checkAttributeName(String name) throws InvalidSchemaException {
  if (!Utf16Util.isXmlName(name)) {
    throw new InvalidSchemaException("Invalid attribute name: " + name);
  }
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
/**
 * Checks whether a UTF-16 string is a valid wave identifier.
 */
public static boolean isValidIdentifier(String id) {
  return !id.isEmpty() && Utf16Util.traverseUtf16String(id, GOOD_UTF16_FOR_ID);
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private AnnotationParser(String input) throws XmlParseException {
  this.input = input;
  ensure(Utf16Util.isValidUtf16(input),
    "Input is not valid UTF-16: ", input);
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private ValidationResult validateAnnotationKey(String key, ViolationCollector v) {
  if (key == null) { return nullAnnotationKey(v); }
  if (key.contains("?") || key.contains("@")) { return invalidCharacterInAnnotationKey(v, key); }
  if (!Utf16Util.isValidUtf16(key)) { return annotationKeyNotValidUtf16(v); }
  return ValidationResult.VALID;
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private ValidationResult validateAnnotationValue(String value, ViolationCollector v) {
if (value == null) { return ValidationResult.VALID; }
if (!Utf16Util.isValidUtf16(value)) { return annotationValueNotValidUtf16(v); }
  return ValidationResult.VALID;
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private void checkValidTagName(String tagName) {
  if (!Utf16Util.isXmlName(tagName)) {
    Preconditions.illegalArgument("Invalid tag name: '" + tagName + "'");
  }
}
 

import org.waveprotocol.wave.model.util.Utf16Util; //导入依赖的package包/类
private void checkValidAttributeName(String tagName) {
  if (!Utf16Util.isXmlName(tagName)) {
    Preconditions.illegalArgument("Invalid attribute name: '" + tagName + "'");
  }
}