Java BlipContentOperation类代码示例

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
/**
 * Deserialize a {@link ProtocolWaveletOperation} as a {@link WaveletOperation}.
 *
 * @param protobufOp protocol buffer wavelet operation to deserialize
 * @return deserialized wavelet operation
 */
public static WaveletOperation deserialize(ProtocolWaveletOperation protobufOp,
    WaveletOperationContext context) {
  if (protobufOp.hasNoOp()) {
    return new NoOp(context);
  } else if (protobufOp.hasAddParticipant()) {
    return new AddParticipant(context, new ParticipantId(protobufOp.getAddParticipant()));
  } else if (protobufOp.hasRemoveParticipant()) {
    return new RemoveParticipant(context, new ParticipantId(protobufOp.getRemoveParticipant()));
  } else if (protobufOp.hasMutateDocument()) {
    return new WaveletBlipOperation(protobufOp.getMutateDocument().getDocumentId(),
        new BlipContentOperation(context,
            deserialize(protobufOp.getMutateDocument().getDocumentOperation())));
  } else {
    throw new IllegalArgumentException("Unsupported operation: " + protobufOp);
  }
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
/**
 * Deserialize a {@link ProtocolWaveletOperation} as a
 * {@link WaveletOperation}.
 *
 * @param protobufOp protocol buffer wavelet operation to deserialize
 * @return deserialized wavelet operation
 */
public static WaveletOperation deserialize(ProtocolWaveletOperation protobufOp,
    WaveletOperationContext ctx) {
  if (protobufOp.hasNoOp()) {
    return new NoOp(ctx);
  } else if (protobufOp.hasAddParticipant()) {
    return new AddParticipant(ctx, new ParticipantId(protobufOp.getAddParticipant()));
  } else if (protobufOp.hasRemoveParticipant()) {
    return new RemoveParticipant(ctx, new ParticipantId(protobufOp.getRemoveParticipant()));
  } else if (protobufOp.hasMutateDocument()) {
    return new WaveletBlipOperation(protobufOp.getMutateDocument().getDocumentId(),
        new BlipContentOperation(ctx, deserialize(protobufOp.getMutateDocument()
            .getDocumentOperation())));
  } else {
    throw new IllegalArgumentException("Unsupported operation: " + protobufOp);
  }
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
@Override
public void consume(BlipOperation operation) throws OperationException {
  WaveletOperationContext context = operation.getContext();
  if (!isContentInitialized() && !IdUtil.isBlipId(blipId)) {
    Preconditions.checkNotNull(preInit, "No initial data");
    if (preInit.isEmpty()) {
      init();
    }
  }
  if (isContentInitialized()) {
    content.consume(operation);
  } else {
    BlipContentOperation contentOperation = (BlipContentOperation)operation;
    preInit.operations.add(new BlipContentOperation(
        new WaveletOperationContext(context.getCreator(), context.getTimestamp(), context.getSegmentVersion()),
        contentOperation.getContentOp(), contentOperation.getContributorMethod()));
    if (contentOperation.isWorthyOfAttribution(blipId)) {
      setLastModifiedTime(context.getTimestamp());
      setLastModifiedVersion(context.getSegmentVersion());
    }
  }
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
/**
 * Constructs an aggregate operation that has the same behaviour as a
 * <code>WaveletBlipOperation</code>.
 *
 * @param op The wavelet blip operation.
 */
AggregateOperation(WaveletBlipOperation op) {
  segmentsToRemove = Collections.emptyList();
  segmentsToAdd = Collections.emptyList();
  segmentsToEndModifying = Collections.emptyList();
  segmentsToStartModifying = Collections.emptyList();
  participantsToRemove = Collections.emptyList();
  participantsToAdd = Collections.emptyList();
  if (op.getBlipOp() instanceof BlipContentOperation) {
  docOps = Collections.singletonList(
      new DocumentOperations(
          op.getBlipId(),
          new DocOpList.Singleton(((BlipContentOperation) op.getBlipOp()).getContentOp())));
  } else {
    docOps = Collections.emptyList();
  }
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
private void checkInsert(WaveletOperation operation, int location, String content,
    int remaining) {
  if (operation instanceof WaveletBlipOperation) {
    WaveletBlipOperation waveOp = (WaveletBlipOperation) operation;
    if (waveOp.getBlipOp() instanceof BlipContentOperation) {
      BlipContentOperation blipOp = (BlipContentOperation) waveOp.getBlipOp();
      DocOpBuilder builder = new DocOpBuilder();
      builder.retain(location).characters(content);
      if (remaining > 0) {
          builder.retain(remaining);
      }
      assertTrue(OpComparators.SYNTACTIC_IDENTITY.equal(builder.build(), blipOp.getContentOp()));
      return;
    }
  }
  fail("Did not get an insertion operation.");
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
/**
 * Creates a wavelet-blip operation from a message.
 *
 * @param context
 * @param message
 * @param checkWellFormed If we should check for wellformness of deserialised DocOp
 * @return a wavelet-blip operation described by {@code message}, or {@code null} if
 *   {@code message} does not describe a blip operation.
 */
private static WaveletBlipOperation createBlipOperation(WaveletOperationContext context,
    ProtocolWaveletOperation message, boolean checkWellFormed)
    throws InvalidInputException {

  if (message.getMutateDocument() != null) {
    MutateDocument opMessage = message.getMutateDocument();
    return new WaveletBlipOperation(opMessage.getDocumentId(), new BlipContentOperation(
        context, createDocumentOperation(opMessage.getDocumentOperation(), checkWellFormed)));
  }
  throw new InvalidInputException("Failed to create blip operation for message " + message);
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
/**
 * Serializes a wavelet operation as a {@link ProtocolWaveletOperation}.
 *
 * @param waveletOp wavelet operation to serialize
 * @return serialized protocol buffer wavelet operation
 */
public static ProtocolWaveletOperation serialize(WaveletOperation waveletOp) {
  ProtocolWaveletOperation.Builder protobufOp = ProtocolWaveletOperation.newBuilder();

  if (waveletOp instanceof NoOp) {
    protobufOp.setNoOp(true);
  } else if (waveletOp instanceof AddParticipant) {
    protobufOp.setAddParticipant(
        ((AddParticipant) waveletOp).getParticipantId().getAddress());
  } else if (waveletOp instanceof RemoveParticipant) {
    protobufOp.setRemoveParticipant(
        ((RemoveParticipant) waveletOp).getParticipantId().getAddress());
  } else if (waveletOp instanceof WaveletBlipOperation) {
    final WaveletBlipOperation wbOp = (WaveletBlipOperation) waveletOp;
    final ProtocolWaveletOperation.MutateDocument.Builder mutation =
      ProtocolWaveletOperation.MutateDocument.newBuilder();
    mutation.setDocumentId(wbOp.getBlipId());
    wbOp.getBlipOp().acceptVisitor(new BlipOperationVisitor() {
      @Override
      public void visitBlipContentOperation(BlipContentOperation blipOp) {
        mutation.setDocumentOperation(serialize(blipOp.getContentOp()));
      }

      @Override
      public void visitSubmitBlip(SubmitBlip op) {
        throw new IllegalArgumentException("Unsupported blip operation: " + wbOp.getBlipOp());
      }
    });
    protobufOp.setMutateDocument(mutation.build());
  } else {
    throw new IllegalArgumentException("Unsupported wavelet operation: " + waveletOp);
  }

  return protobufOp.build();
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
@Timed
static Map<SegmentId, SegmentOperation> makeSegmentOperations(WaveletDeltaRecord delta) {
  LoadingCache<SegmentId, ImmutableList.Builder<WaveletOperation>> builders = CacheBuilder.newBuilder().build(
    new CacheLoader<SegmentId, ImmutableList.Builder<WaveletOperation>>(){

    @Override
    public ImmutableList.Builder<WaveletOperation> load(SegmentId segmentId) {
      return ImmutableList.builder();
    }
  });
  Map<SegmentId, SegmentOperation> segmentOperations = CollectionUtils.newHashMap();
  for (WaveletOperation op : delta.getTransformedDelta()) {
    WaveletOperationContext newContext = makeSegmentContext(op.getContext(), delta.getResultingVersion().getVersion());
    if (op instanceof AddParticipant) {
      builders.getUnchecked(SegmentId.PARTICIPANTS_ID).add(
        new AddParticipant(newContext, ((AddParticipant)op).getParticipantId()));
    } else if (op instanceof RemoveParticipant) {
      builders.getUnchecked(SegmentId.PARTICIPANTS_ID).add(
        new RemoveParticipant(newContext, ((RemoveParticipant)op).getParticipantId()));
    } else if (op instanceof NoOp) {
      builders.getUnchecked(SegmentId.PARTICIPANTS_ID).add(new NoOp(newContext));
    } else {
      WaveletBlipOperation blipOp = (WaveletBlipOperation)op;
      BlipContentOperation blipContentOp = (BlipContentOperation)blipOp.getBlipOp();
      BlipContentOperation newBlipContentOp = new BlipContentOperation(newContext,
        blipContentOp.getContentOp(), blipContentOp.getContributorMethod());
      WaveletBlipOperation newBlipOp = new WaveletBlipOperation(blipOp.getBlipId(), newBlipContentOp);
      builders.getUnchecked(SegmentId.ofBlipId(blipOp.getBlipId())).add(newBlipOp);
    }
  }
  for (Entry<SegmentId, ImmutableList.Builder<WaveletOperation>> entry : builders.asMap().entrySet()) {
    segmentOperations.put(entry.getKey(), new SegmentOperationImpl(entry.getValue().build()));
  }
  return segmentOperations;
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
private void prepareOperation(WaveletOperation op) {
  if (op instanceof AddParticipant) {
    log(3, "AddParticipant " + ((AddParticipant)op).getParticipantId().toString());
  } else if (op instanceof RemoveParticipant) {
    log(3, "RemoveParticipant " + ((RemoveParticipant)op).getParticipantId().toString());
  } else if (op instanceof WaveletBlipOperation) {
    WaveletBlipOperation waveletBlipOp = (WaveletBlipOperation) op;
    BlipOperation blipOp = waveletBlipOp.getBlipOp();
    if (blipOp instanceof BlipContentOperation) {
      DocOp docOp = ((BlipContentOperation) blipOp).getContentOp();
      log(3, "BlipId=" + waveletBlipOp.getBlipId() + ", Op=" + operationToString(docOp) +
          ", OpSize=" + docOp.size());
    }
  }
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
public static DBObject serialize(WaveletOperation waveletOp) {
  final BasicDBObject mongoOp = new BasicDBObject();

  if (waveletOp instanceof NoOp) {
    mongoOp.append(FIELD_TYPE, WAVELET_OP_NOOP);

  } else if (waveletOp instanceof AddParticipant) {
    mongoOp.append(FIELD_TYPE, WAVELET_OP_ADD_PARTICIPANT);
    mongoOp.append(FIELD_PARTICIPANT, serialize(((AddParticipant) waveletOp).getParticipantId()));

  } else if (waveletOp instanceof RemoveParticipant) {
    mongoOp.append(FIELD_TYPE, WAVELET_OP_REMOVE_PARTICIPANT);
    mongoOp.append(FIELD_PARTICIPANT,
        serialize(((RemoveParticipant) waveletOp).getParticipantId()));
  } else if (waveletOp instanceof WaveletBlipOperation) {
    final WaveletBlipOperation waveletBlipOp = (WaveletBlipOperation) waveletOp;

    mongoOp.append(FIELD_TYPE, WAVELET_OP_WAVELET_BLIP_OPERATION);
    mongoOp.append(FIELD_BLIPID, waveletBlipOp.getBlipId());

    if (waveletBlipOp.getBlipOp() instanceof BlipContentOperation) {
      mongoOp.append(FIELD_BLIPOP, serialize((BlipContentOperation) waveletBlipOp.getBlipOp()));
    } else {
      throw new IllegalArgumentException("Unsupported blip operation: "
          + waveletBlipOp.getBlipOp());
    }
  } else {
    throw new IllegalArgumentException("Unsupported wavelet operation: " + waveletOp);
  }
  return mongoOp;
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
/**
 * Serialize a {@link DocOp} as a {@link ProtocolDocumentOperation}.
 *
 * @param blipOp document operation to serialize
 * @return serialized protocol buffer document operation
 */
public ProtocolDocumentOperation serialize(BlipOperation blipOp) {
  ProtocolDocumentOperation output;

  if (blipOp instanceof BlipContentOperation) {
    output = serialize(((BlipContentOperation) blipOp).getContentOp());
  } else if (blipOp instanceof SubmitBlip) {
    // we don't support this operation here.
    output = adaptor.createProtocolDocumentOperation();
  } else {
    throw new IllegalArgumentException("Unsupported operation type: " + blipOp);
  }
  return output;
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
private void serializeOperation(WaveletOperation operation, ProtoWaveletOperation serialized) {
  if (operation instanceof AddSegment) {
    serialized.setAddSegment(
      serializeOptionalSegmentId(((AddSegment)operation).getSegmentId()));
  } else if (operation instanceof RemoveSegment) {
    serialized.setRemoveSegment(
      serializeOptionalSegmentId(((RemoveSegment)operation).getSegmentId()));
  } else if (operation instanceof StartModifyingSegment) {
    serialized.setStartModifyingSegment(
      serializeOptionalSegmentId(((StartModifyingSegment)operation).getSegmentId()));
  } else if (operation instanceof EndModifyingSegment) {
    serialized.setEndModifyingSegment(
      serializeOptionalSegmentId(((EndModifyingSegment)operation).getSegmentId()));
  } else if (operation instanceof AddParticipant) {
    serialized.setAddParticipant(((AddParticipant)operation).getParticipantId().getAddress());
  } else if (operation instanceof RemoveParticipant) {
    serialized.setRemoveParticipant(((RemoveParticipant)operation).getParticipantId().getAddress());
  } else if (operation instanceof WaveletBlipOperation) {
    WaveletBlipOperation waveletOp = (WaveletBlipOperation)operation;
    BlipContentOperation blipOp = (BlipContentOperation)waveletOp.getBlipOp();
    switch (blipOp.getContributorMethod()) {
    case ADD:
      serialized.setAddDocumentContributor(true);
      break;
    case REMOVE:
      serialized.setRemoveDocumentContributor(true);
      break;
    }
    serialized.setDocumentOperation(operationSerializer.serialize(blipOp.getContentOp()));
  } else if (operation instanceof NoOp) {
    serialized.setNoOp(true);
  } else {
    throw new RuntimeException("Bad operation type");
  }
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
private WaveletOperation deserializeOperation(ProtoWaveletOperation operation,
    SegmentId segmentId, WaveletOperationContext context) throws InvalidParticipantAddress {
  if (operation.hasAddSegment()) {
    return new AddSegment(context, deserializeOptionalSegmentId(operation.getAddSegment()));
  }
  if (operation.hasRemoveSegment()) {
    return new RemoveSegment(context, deserializeOptionalSegmentId(operation.getRemoveSegment()));
  }
  if (operation.hasStartModifyingSegment()) {
    return new StartModifyingSegment(context, deserializeOptionalSegmentId(operation.getStartModifyingSegment()));
  }
  if (operation.hasEndModifyingSegment()) {
    return new EndModifyingSegment(context, deserializeOptionalSegmentId(operation.getEndModifyingSegment()));
  }
  if (operation.hasAddParticipant()) {
    return new AddParticipant(context, ParticipantId.of(operation.getAddParticipant()));
  }
  if (operation.hasRemoveParticipant()) {
    return new RemoveParticipant(context, ParticipantId.of(operation.getRemoveParticipant()));
  }
  if (operation.hasDocumentOperation()) {
    BlipOperation.UpdateContributorMethod method = BlipOperation.UpdateContributorMethod.NONE;
    if (operation.hasAddDocumentContributor()) {
      method = BlipOperation.UpdateContributorMethod.ADD;
    } else if (operation.hasRemoveDocumentContributor()) {
      method = BlipOperation.UpdateContributorMethod.REMOVE;
    }
    DocOp docOp = WaveletOperationSerializer.deserialize(operation.getDocumentOperation());
    BlipContentOperation blipOp = new BlipContentOperation(context, docOp, method);
    return new WaveletBlipOperation(segmentId.getBlipId(), blipOp);
  }
  if (operation.hasNoOp()) {
    return new NoOp(context);
  }
  Preconditions.nullPointer("Invalid operation " + operation);
  return null; // unreachable
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
/**
 * Implements the strategy for consuming operations sent to this adapter from
 * a document adapter, after the operation has already been applied locally. A
 * received operation is boxed as a blip operation, then used to update the
 * primitive blip, then boxed as a wave operation and sent to the wavelet
 * adapter.
 */
private void consume(DocOp op) {
  // Box as blip op, and update local blip
  BlipContentOperation blipOp = new BlipContentOperation(wavelet.createContext(), op);
  blipOp.update(OpBasedBlip.this.blip);
  // Box as wavelet op, and pass to wavelet adapter
  outputSink.consume(new WaveletBlipOperation(getId(), blipOp));
}
 

import org.waveprotocol.wave.model.operation.wave.BlipContentOperation; //导入依赖的package包/类
public void optimise() {
  int startSize = size();
  if (startSize == 1) {
    return;
  }

  ArrayList<DocOp> docOps = CollectionUtils.newArrayList();
  List<WaveletOperation> oldOperations = CollectionUtils.newArrayList(this);
  String currentId = null;
  WaveletOperationContext lastOperationContext = null;
  this.clear();

  for (WaveletOperation waveletOp : oldOperations) {
    if (waveletOp instanceof WaveletBlipOperation) {
      WaveletBlipOperation waveletBlipOp = ((WaveletBlipOperation) waveletOp);
      String id = waveletBlipOp.getBlipId();
      BlipOperation blipOp = waveletBlipOp.getBlipOp();
      if (blipOp instanceof BlipContentOperation) {
        if (!docOps.isEmpty() && !id.equals(currentId)) {
          composeDocOps(this, currentId, lastOperationContext, docOps);
        }
        docOps.add(((BlipContentOperation) blipOp).getContentOp());
        lastOperationContext = blipOp.getContext();
        currentId = id;
        continue;
      }
    }
    if (!docOps.isEmpty()) {
      composeDocOps(this, currentId, lastOperationContext, docOps);
    }
    add(waveletOp);
  }
  if (!docOps.isEmpty()) {
    composeDocOps(this, currentId, lastOperationContext, docOps);
  }
}