Java Attributes类代码示例

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
private boolean containsAnnotationKey(DocInitialization content, final String key) {
  final boolean[] found = { false };
  content.apply(new DocInitializationCursor() {
      @Override public void characters(String chars) {}
      @Override public void elementStart(String type, Attributes attrs) {}
      @Override public void elementEnd() {}
      @Override public void annotationBoundary(AnnotationBoundaryMap map) {
        for (int i = 0; i < map.changeSize(); i++) {
          if (key.equals(map.getChangeKey(i))) {
            found[0] = true;
          }
        }
      }
    });
  return found[0];
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
/** Check that generating an op from just an element calls element start & end. */
public void testOperationFromElementNotRecursive() {
  Bundle data = new Bundle();
  DocOpBuffer cursorA = new DocOpBuffer(), cursorB = new DocOpBuffer();
  DomOperationUtil.buildDomInitializationFromElement(data.D, data.A.asElement(), cursorA, false);
  cursorB.elementStart("a", Attributes.EMPTY_MAP);
  cursorB.elementEnd();

  checkCursors(cursorA, cursorB);

  // do likewise with B
  cursorA = new DocOpBuffer();
  cursorB = new DocOpBuffer();
  DomOperationUtil.buildDomInitializationFromElement(data.D, data.B.asElement(), cursorA, false);
  cursorB.elementStart("b", new AttributesImpl(Collections.singletonMap("x", "y")));
  cursorB.elementEnd();

  checkCursors(cursorA, cursorB);
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void doTestInserts() throws OperationException {
  String a = "<p>abc<b>def</b></p>";

  create(a);

  Element firstEl = (Element) doc.getFirstChild(doc.getDocumentElement());

  Builder b = at(0);
  Attributes attrs = attrs("x", "1", "y", "2");
  b.replaceAttributes(attrs);
  b.elementStart("x", attrs("a", "1"));
  b.characters("hello");
  b.elementStart("y", attrs("b", "2", "c", "3"));
  b.characters("yeah");
  b.elementEnd();
  b.elementEnd();
  String moreText = "more text";
  b.characters(moreText);
  consumeNindo(b.build());

  checkEvents(
      am(firstEl, pairs("x", null, "y", null), attrs),
      ci(doc.asElement(firstEl.getFirstChild())),
      ti(14, moreText));
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
public void testOpenDuringInsertionThenUpdate() throws OperationException {
   IndexedDocument<Node, Element, Text> doc =
DocProviders.POJO.parse("<q><r/></q>abcdefghijkl");

   Nindo.Builder b;

   b = new Nindo.Builder();
   b.startAnnotation("a", "1");
   b.skip(7);
   b.endAnnotation("a");
   checkApply(doc, b.build());

   b = new Nindo.Builder();
   b.elementStart("p", Attributes.EMPTY_MAP);
   b.startAnnotation("a", null);
   b.elementEnd();
   b.updateAttributes(Collections.singletonMap("u", "v"));
   b.replaceAttributes(new AttributesImpl("v", "u"));
   b.skip(1);
   b.endAnnotation("a");
   checkApply(doc, b.build());
 }
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
@Override
final Handler pushHandler(String type, Attributes attrs) throws InvalidSchemaException {
  // NOTE: Is it worth using a map here?
  if (type.equals(PROLOGUE_TYPE_NAME)) {
    return new PrologueHandler(this);
  } else if (type.equals(ATTRIBUTE_TYPE_NAME)) {
    handleAttribute(attrs);
    return new EmptyHandler(this);
  } else if (type.equals(ELEMENT_TYPE_NAME)) {
    String name = extractName(ELEMENT_TYPE_NAME, attrs);
    if (freeElements.containsKey(name)) {
      throw new InvalidSchemaException("Element pattern defined more than once: " + name);
    }
    return new ElementHandler(name, this);
  } else if (type.equals(TEXT_TYPE_NAME)) {
    handleText(attrs);
    return new EmptyHandler(this);
  } else if (type.equals(REFERENCE_TYPE_NAME)) {
    handleReference(attrs);
    return new EmptyHandler(this);
  }
  throw new InvalidSchemaException("Unrecognized element type: " + type);
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
private TestDocumentContext<Node, Element, Text> createAlignTestCxt() {
  // creates the following, where '<t>' are soft nodes
  // <div>
  //   <p>A</p>
  //   <p> <t>Z</t> </p>
  //   <p> <t><t/></t> </p>
  // </div>
  String initialContent = "<p>A</p><p>Z</p><p></p>";
  TestDocumentContext<Node, Element, Text> cxt = ContextProviders.createTestPojoContext(
      DocProviders.POJO.parse(initialContent).asOperation(), null, null, null,
        DocumentSchema.NO_SCHEMA_CONSTRAINTS);

  LocalDocument<Node, Element, Text> doc = cxt.annotatableContent();
  Text zText = doc.getDocumentElement().getFirstChild().getNextSibling().getFirstChild().asText();

  // First transparent part, moving the Z inside
  Element trans = doc.transparentCreate("S", Attributes.EMPTY_MAP,
      zText.getParentElement(), zText);
  cxt.annotatableContent().transparentMove(trans, zText, null, null);

  // Second transparent part, deep transparent (contains another transparent element)
  Element lastP = doc.getDocumentElement().getLastChild().asElement();
  trans = cxt.annotatableContent().transparentCreate("T", Attributes.EMPTY_MAP, lastP, null);
  cxt.annotatableContent().transparentCreate("U", Attributes.EMPTY_MAP, trans, null);
  return cxt;
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
public static String toConciseString(Attributes attributes) {
  if (attributes.isEmpty()) {
    return "{}";
  }
  StringBuilder b = new StringBuilder();
  b.append("{ ");
  boolean first = true;
  for (Map.Entry<String, String> entry : attributes.entrySet()) {
    if (first) {
      first = false;
    } else {
      b.append(", ");
    }
    b.append(entry.getKey());
    b.append("=");
    b.append(literalString(entry.getValue()));
  }
  b.append(" }");
  return b.toString();
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
public void testAnnotationBoundary() {
  DocOpBuilder m = new DocOpBuilder();

  Attributes a = new AttributesImpl(ImmutableMap.of("a1", "1", "a2", "2"));
  AnnotationBoundaryMap mapA = new AnnotationBoundaryMapImpl(
      new String[]{},new String[]{"a"},new String[]{null},new String[]{"b"});
  AnnotationBoundaryMap mapB = new AnnotationBoundaryMapImpl(
      new String[]{},new String[]{"a"},new String[]{"b"},new String[]{null});
  AnnotationBoundaryMap mapC = new AnnotationBoundaryMapImpl(
      new String[]{"a"},new String[]{},new String[]{},new String[]{});
  m.elementStart("a", a);
  m.annotationBoundary(mapA);
  m.characters("test");
  m.annotationBoundary(mapB);
  m.characters("text");
  m.annotationBoundary(mapC);
  m.elementEnd();

  assertReversible(makeBlipOp("annotationBoundary", m.build()));
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
public static String attributeString(Attributes attributes) {
  StringBuilder b = new StringBuilder();
  boolean first = true;
  for (Map.Entry<String, String> e : attributes.entrySet()) {
    if (first) {
      first = false;
    } else {
      b.append(" ");
    }
    // We're just writing null with no quotes if the value is null.
    // This is acceptable since it only occurs in updateAttributes,
    // which is a processing instruction, so we define the format of it.
    //
    // TODO: We should escape ' and " and < and & etc. in the value.
    b.append(e.getKey()).append("=")
        .append(e.getValue() == null ? "null"
        : ("\"" + xmlAttrEscape(e.getValue()) + "\""));
  }
  return b.toString();
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
/**
 * Creates an operation to delete the XML fragment "12<u>3<i/><b/>4</u>56".
 *
 * @param size The size of the document on which this operation should apply.
 * @param location The start of the range where the fragment to be deleted
 *        resides.
 * @return The operation.
 */
private static DocOp structuralDeletionSample3(int size, int location) {
  return new DocOpBuilder()
      .retain(location)
      .deleteCharacters("12")
      .deleteElementStart("u", Attributes.EMPTY_MAP)
      .deleteCharacters("3")
      .deleteElementStart("i", Attributes.EMPTY_MAP)
      .deleteElementEnd()
      .deleteElementStart("b", Attributes.EMPTY_MAP)
      .deleteElementEnd()
      .deleteCharacters("4")
      .deleteElementEnd()
      .deleteCharacters("56")
      .retain(size - location - 12)
      .build();
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
public void testDeleteCharactersAndElements() {
  DocOpBuilder m = new DocOpBuilder();

  Attributes a = new AttributesImpl(ImmutableMap.of("a1", "1", "a2", "2"));
  Attributes b = new AttributesImpl();
  Attributes c = new AttributesImpl(ImmutableMap.of("c1", "1", "c2", "2", "c3", "3"));

  m.deleteElementStart("a", a);
  m.deleteCharacters("hello");
  m.deleteElementStart("b", b);
  m.deleteCharacters("world");
  m.deleteElementStart("c", c);
  m.deleteElementEnd();
  m.deleteCharacters("blah");
  m.deleteElementEnd();
  m.deleteElementEnd();

  assertReversible(makeBlipOp("deleteCharactersAndElements", m.build()));
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
private static ElementStart createElementStart(String type, Attributes attrs) {
  ElementStart elementStart = MessageFactoryHelper.createDocumentElementStart();
  elementStart.setType(type);
  for (Map.Entry<String, String> attribute : attrs.entrySet()) {
    elementStart.addAttribute(
        createKeyValuePair(attribute.getKey(), attribute.getValue()));
  }
  return elementStart;
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
private Attributes newAttributesFrom(ReplaceAttributes message) {
  List<Attribute> attributes = new ArrayList<Attribute>();
  for (int i = 0; i < message.getNewAttributeSize(); i++) {
    KeyValuePair p = message.getNewAttribute(i);
    attributes.add(new Attribute(p.getKey(), p.getValue()));
  }
  return createAttributesImpl(attributes);
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
@Override
public void setElementAttributes(E element, Attributes attrs) {
  Preconditions.checkArgument(element != getDocumentElement(), "Cannot touch root element");
  try {
    begin();
    consume(setAttributes(attrs, at(Locator.before(doc, element))));
  } finally {
    end();
  }
}
 

import org.waveprotocol.wave.model.document.operation.Attributes; //导入依赖的package包/类
/**
 * Renders a document as a paragraph of plain text.
 */
public static void render(DocInitialization doc, final StringBuilder out) {
  checkNotNull(doc, "Null doc");
  checkNotNull(out, "Null out");
  doc.apply(new DocInitializationCursor() {
    @Override
    public void characters(String chars) {
      out.append(chars);
    }

    @Override
    public void elementStart(String type, Attributes attrs) {
      out.append(' ');
    }

    @Override
    public void elementEnd() {
      out.append(' ');
    }

    @Override
    public void annotationBoundary(AnnotationBoundaryMap map) {
      // Ignore
    }
  });
  out.append("\n");
}