@Override
  public ReturnCode filterCell(Cell c) throws IOException {
    if (isEmpty()) {
      return ReturnCode.INCLUDE;
    }
    ReturnCode rc = null;
    for (int i = 0, n = filters.size(); i < n; i++) {
      Filter filter = filters.get(i);
      subFiltersIncludedCell.set(i, false);

      Cell prevCell = this.prevCellList.get(i);
      ReturnCode prevCode = this.prevFilterRCList.get(i);
      if (filter.filterAllRemaining()) {
        continue;
      }
      ReturnCode localRC = calculateReturnCodeByPrevCellAndRC(filter, c, prevCell, prevCode);
      if (localRC == null) {
        // Can not get return code based on previous cell and previous return code. In other words,
        // we should pass the current cell to this sub-filter to get the return code, and it won't
        // impact the sub-filter's internal state.
        localRC = filter.filterCell(c);
      }

      // Update previous return code and previous cell for filter[i].
      updatePrevFilterRCList(i, localRC);
      updatePrevCellList(i, c, localRC);

      rc = mergeReturnCode(rc, localRC);

      // For INCLUDE* case, we need to update the transformed cell.
      if (
        isInReturnCodes(localRC, ReturnCode.INCLUDE, ReturnCode.INCLUDE_AND_NEXT_COL,
          ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW)
      ) {
        subFiltersIncludedCell.set(i, true);
      }
    }
    // Each sub-filter in filter list got true for filterAllRemaining(), if rc is null, so we should
    // return SKIP.
    return rc == null ? ReturnCode.SKIP : rc;
  }
FilterList with MUST_PASS_ONE choose the minimal forward step among sub-filter in filter list.
Let's call it: The Minimal Step Rule. So if filter-A in filter list return INCLUDE and filter-B
in filter list return INCLUDE_AND_NEXT_COL, then the filter list should return INCLUDE. For
SEEK_NEXT_USING_HINT, it's more special, because we do not know how far it will forward, so we
use SKIP by default.<br/>
<br/>
The jump step will be:

<pre>
INCLUDE &lt; SKIP &lt; INCLUDE_AND_NEXT_COL &lt; NEXT_COL &lt; INCLUDE_AND_SEEK_NEXT_ROW &lt; NEXT_ROW
    &lt; SEEK_NEXT_USING_HINT
</pre>

Here, we have the following map to describe The Minimal Step Rule. if current return code (for
previous sub-filters in filter list) is <strong>ReturnCode</strong>, and current filter returns
<strong>localRC</strong>, then we should return map[ReturnCode][localRC] for the merged result,
according to The Minimal Step Rule.<br/>

<pre>
LocalCode\ReturnCode       INCLUDE INCLUDE_AND_NEXT_COL     INCLUDE_AND_SEEK_NEXT_ROW  SKIP      NEXT_COL              NEXT_ROW                  SEEK_NEXT_USING_HINT
INCLUDE                    INCLUDE INCLUDE                  INCLUDE                    INCLUDE   INCLUDE               INCLUDE                   INCLUDE
INCLUDE_AND_NEXT_COL       INCLUDE INCLUDE_AND_NEXT_COL     INCLUDE_AND_NEXT_COL       INCLUDE   INCLUDE_AND_NEXT_COL  INCLUDE_AND_NEXT_COL      INCLUDE
INCLUDE_AND_SEEK_NEXT_ROW  INCLUDE INCLUDE_AND_NEXT_COL     INCLUDE_AND_SEEK_NEXT_ROW  INCLUDE   INCLUDE_AND_NEXT_COL  INCLUDE_AND_SEEK_NEXT_ROW INCLUDE
SKIP                       INCLUDE INCLUDE                  INCLUDE                    SKIP      SKIP                  SKIP                      SKIP
NEXT_COL                   INCLUDE INCLUDE_AND_NEXT_COL     INCLUDE_AND_NEXT_COL       SKIP      NEXT_COL              NEXT_COL                  SKIP
NEXT_ROW                   INCLUDE INCLUDE_AND_NEXT_COL     INCLUDE_AND_SEEK_NEXT_ROW  SKIP      NEXT_COL              NEXT_ROW                  SKIP
SEEK_NEXT_USING_HINT       INCLUDE INCLUDE                  INCLUDE                    SKIP      SKIP                  SKIP                      SEEK_NEXT_USING_HINT
</pre>

@param rc      Return code which is calculated by previous sub-filter(s) in filter list.
@param localRC Return code of the current sub-filter in filter list.
@return Return code which is merged by the return code of previous sub-filter(s) and the return
        code of current sub-filter.
hbase-client/src/main/java/org/apache/hadoop/hbase/filter/FilterListWithOR.java