public ProcessorResult applyOperation()

in firebase-database/src/main/java/com/google/firebase/database/core/view/ViewProcessor.java [60:168]
105 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 {
            hardAssert(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 {
            hardAssert(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, optCompleteCache, accumulator);
          break;
        }
      default:
        {
          throw new AssertionError("Unknown operation: " + operation.getType());
        }
    }
    List<Change> changes = new ArrayList<Change>(accumulator.getChanges());
    maybeAddValueEvent(oldViewCache, newViewCache, changes);
    return new ProcessorResult(newViewCache, changes);
  }