public ProcessorResult applyOperation()

in src/main/java/com/google/firebase/database/core/view/ViewProcessor.java [68:178]
104 lines of code
11 McCabe index (conditional complexity)

  public ProcessorResult applyOperation(
      ViewCache oldViewCache,
      Operation operation,
      WriteTreeRef writesCache,
      Node optCompleteCache) {
    ChildChangeAccumulator accumulator = new ChildChangeAccumulator();
    ViewCache newViewCache;
    switch (operation.getType()) {
      case Overwrite:
      {
        Overwrite overwrite = (Overwrite) operation;
        if (overwrite.getSource().isFromUser()) {
          newViewCache =
              this.applyUserOverwrite(
                  oldViewCache,
                  overwrite.getPath(),
                  overwrite.getSnapshot(),
                  writesCache,
                  optCompleteCache,
                  accumulator);
        } else {
          assert overwrite.getSource().isFromServer();
          // We filter the node if it's a tagged update or the node has been previously
          // filtered
          // and the update is not at the root in which case it is ok (and necessary)
          // to mark the
          // node unfiltered again
          boolean filterServerNode =
              overwrite.getSource().isTagged()
              || (oldViewCache.getServerCache().isFiltered()
                  && !overwrite.getPath().isEmpty());
          newViewCache =
              this.applyServerOverwrite(
                  oldViewCache,
                  overwrite.getPath(),
                  overwrite.getSnapshot(),
                  writesCache,
                  optCompleteCache,
                  filterServerNode,
                  accumulator);
        }
        break;
      }
      case Merge:
      {
        Merge merge = (Merge) operation;
        if (merge.getSource().isFromUser()) {
          newViewCache =
              this.applyUserMerge(
                  oldViewCache,
                  merge.getPath(),
                  merge.getChildren(),
                  writesCache,
                  optCompleteCache,
                  accumulator);
        } else {
          assert merge.getSource().isFromServer();
          // We filter the node if it's a tagged update or the node has been previously
          // filtered
          boolean filterServerNode =
              merge.getSource().isTagged() || oldViewCache.getServerCache().isFiltered();
          newViewCache =
              this.applyServerMerge(
                  oldViewCache,
                  merge.getPath(),
                  merge.getChildren(),
                  writesCache,
                  optCompleteCache,
                  filterServerNode,
                  accumulator);
        }
        break;
      }
      case AckUserWrite:
      {
        AckUserWrite ackUserWrite = (AckUserWrite) operation;
        if (!ackUserWrite.isRevert()) {
          newViewCache =
              this.ackUserWrite(
                  oldViewCache,
                  ackUserWrite.getPath(),
                  ackUserWrite.getAffectedTree(),
                  writesCache,
                  optCompleteCache,
                  accumulator);
        } else {
          newViewCache =
              this.revertUserWrite(
                  oldViewCache,
                  ackUserWrite.getPath(),
                  writesCache,
                  optCompleteCache,
                  accumulator);
        }
        break;
      }
      case ListenComplete:
      {
        newViewCache =
            this.listenComplete(oldViewCache, operation.getPath(), writesCache, accumulator);
        break;
      }
      default:
      {
        throw new AssertionError("Unknown operation: " + operation.getType());
      }
    }
    List<Change> changes = new ArrayList<>(accumulator.getChanges());
    maybeAddValueEvent(oldViewCache, newViewCache, changes);
    return new ProcessorResult(newViewCache, changes);
  }