private ReturnCode mergeReturnCode(ReturnCode rc, ReturnCode localRC) {
    if (rc == null) return localRC;
    switch (localRC) {
      case INCLUDE:
        return ReturnCode.INCLUDE;
      case INCLUDE_AND_NEXT_COL:
        if (
          isInReturnCodes(rc, ReturnCode.INCLUDE, ReturnCode.SKIP, ReturnCode.SEEK_NEXT_USING_HINT)
        ) {
          return ReturnCode.INCLUDE;
        }
        if (
          isInReturnCodes(rc, ReturnCode.INCLUDE_AND_NEXT_COL, ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW,
            ReturnCode.NEXT_COL, ReturnCode.NEXT_ROW)
        ) {
          return ReturnCode.INCLUDE_AND_NEXT_COL;
        }
        break;
      case INCLUDE_AND_SEEK_NEXT_ROW:
        if (
          isInReturnCodes(rc, ReturnCode.INCLUDE, ReturnCode.SKIP, ReturnCode.SEEK_NEXT_USING_HINT)
        ) {
          return ReturnCode.INCLUDE;
        }
        if (isInReturnCodes(rc, ReturnCode.INCLUDE_AND_NEXT_COL, ReturnCode.NEXT_COL)) {
          return ReturnCode.INCLUDE_AND_NEXT_COL;
        }
        if (isInReturnCodes(rc, ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW, ReturnCode.NEXT_ROW)) {
          return ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW;
        }
        break;
      case SKIP:
        if (
          isInReturnCodes(rc, ReturnCode.INCLUDE, ReturnCode.INCLUDE_AND_NEXT_COL,
            ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW)
        ) {
          return ReturnCode.INCLUDE;
        }
        if (
          isInReturnCodes(rc, ReturnCode.SKIP, ReturnCode.NEXT_COL, ReturnCode.NEXT_ROW,
            ReturnCode.SEEK_NEXT_USING_HINT)
        ) {
          return ReturnCode.SKIP;
        }
        break;
      case NEXT_COL:
        if (isInReturnCodes(rc, ReturnCode.INCLUDE)) {
          return ReturnCode.INCLUDE;
        }
        if (isInReturnCodes(rc, ReturnCode.NEXT_COL, ReturnCode.NEXT_ROW)) {
          return ReturnCode.NEXT_COL;
        }
        if (
          isInReturnCodes(rc, ReturnCode.INCLUDE_AND_NEXT_COL, ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW)
        ) {
          return ReturnCode.INCLUDE_AND_NEXT_COL;
        }
        if (isInReturnCodes(rc, ReturnCode.SKIP, ReturnCode.SEEK_NEXT_USING_HINT)) {
          return ReturnCode.SKIP;
        }
        break;
      case NEXT_ROW:
        if (isInReturnCodes(rc, ReturnCode.INCLUDE)) {
          return ReturnCode.INCLUDE;
        }
        if (isInReturnCodes(rc, ReturnCode.INCLUDE_AND_NEXT_COL)) {
          return ReturnCode.INCLUDE_AND_NEXT_COL;
        }
        if (isInReturnCodes(rc, ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW)) {
          return ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW;
        }
        if (isInReturnCodes(rc, ReturnCode.SKIP, ReturnCode.SEEK_NEXT_USING_HINT)) {
          return ReturnCode.SKIP;
        }
        if (isInReturnCodes(rc, ReturnCode.NEXT_COL)) {
          return ReturnCode.NEXT_COL;
        }
        if (isInReturnCodes(rc, ReturnCode.NEXT_ROW)) {
          return ReturnCode.NEXT_ROW;
        }
        break;
      case SEEK_NEXT_USING_HINT:
        if (
          isInReturnCodes(rc, ReturnCode.INCLUDE, ReturnCode.INCLUDE_AND_NEXT_COL,
            ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW)
        ) {
          return ReturnCode.INCLUDE;
        }
        if (isInReturnCodes(rc, ReturnCode.SKIP, ReturnCode.NEXT_COL, ReturnCode.NEXT_ROW)) {
          return ReturnCode.SKIP;
        }
        if (isInReturnCodes(rc, ReturnCode.SEEK_NEXT_USING_HINT)) {
          return ReturnCode.SEEK_NEXT_USING_HINT;
        }
        break;
    }
    throw new IllegalStateException(
      "Received code is not valid. rc: " + rc + ", localRC: " + localRC);
  }
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