public FilterModel()

in hbase-rest/src/main/java/org/apache/hadoop/hbase/rest/model/ScannerModel.java [450:566]


    public FilterModel(Filter filter) {
      String typeName = filter.getClass().getSimpleName();
      FilterType type = FilterType.valueOf(typeName);
      this.type = typeName;
      switch (type) {
        case ColumnCountGetFilter:
          this.limit = ((ColumnCountGetFilter) filter).getLimit();
          break;
        case ColumnPaginationFilter:
          this.limit = ((ColumnPaginationFilter) filter).getLimit();
          this.offset = ((ColumnPaginationFilter) filter).getOffset();
          break;
        case ColumnPrefixFilter:
          byte[] src = ((ColumnPrefixFilter) filter).getPrefix();
          this.value = Bytes.toString(Base64.getEncoder().encode(src));
          break;
        case ColumnRangeFilter:
          ColumnRangeFilter crf = (ColumnRangeFilter) filter;
          this.minColumn = Bytes.toString(Base64.getEncoder().encode(crf.getMinColumn()));
          this.minColumnInclusive = crf.getMinColumnInclusive();
          this.maxColumn = Bytes.toString(Base64.getEncoder().encode(crf.getMaxColumn()));
          this.maxColumnInclusive = crf.getMaxColumnInclusive();
          break;
        case DependentColumnFilter: {
          DependentColumnFilter dcf = (DependentColumnFilter) filter;
          this.family = Bytes.toString(Base64.getEncoder().encode(dcf.getFamily()));
          byte[] qualifier = dcf.getQualifier();
          if (qualifier != null) {
            this.qualifier = Bytes.toString(Base64.getEncoder().encode(qualifier));
          }
          this.op = dcf.getCompareOperator().toString();
          this.comparator = new ByteArrayComparableModel(dcf.getComparator());
          this.dropDependentColumn = dcf.dropDependentColumn();
        }
          break;
        case FilterList:
          this.op = ((FilterList) filter).getOperator().toString();
          this.filters = new ArrayList<>();
          for (Filter child : ((FilterList) filter).getFilters()) {
            this.filters.add(new FilterModel(child));
          }
          break;
        case FirstKeyOnlyFilter:
        case KeyOnlyFilter:
          break;
        case InclusiveStopFilter:
          this.value = Bytes
            .toString(Base64.getEncoder().encode(((InclusiveStopFilter) filter).getStopRowKey()));
          break;
        case MultipleColumnPrefixFilter:
          this.prefixes = new ArrayList<>();
          for (byte[] prefix : ((MultipleColumnPrefixFilter) filter).getPrefix()) {
            this.prefixes.add(Bytes.toString(Base64.getEncoder().encode(prefix)));
          }
          break;
        case MultiRowRangeFilter:
          this.ranges = new ArrayList<>();
          for (RowRange range : ((MultiRowRangeFilter) filter).getRowRanges()) {
            this.ranges.add(new RowRangeModel(range));
          }
          break;
        case PageFilter:
          this.value = Long.toString(((PageFilter) filter).getPageSize());
          break;
        case PrefixFilter:
          this.value =
            Bytes.toString(Base64.getEncoder().encode(((PrefixFilter) filter).getPrefix()));
          break;
        case FamilyFilter:
        case QualifierFilter:
        case RowFilter:
        case ValueFilter:
          this.op = ((CompareFilter) filter).getCompareOperator().toString();
          this.comparator = new ByteArrayComparableModel(((CompareFilter) filter).getComparator());
          break;
        case RandomRowFilter:
          this.chance = ((RandomRowFilter) filter).getChance();
          break;
        case SingleColumnValueExcludeFilter:
        case SingleColumnValueFilter: {
          SingleColumnValueFilter scvf = (SingleColumnValueFilter) filter;
          this.family = Bytes.toString(Base64.getEncoder().encode(scvf.getFamily()));
          byte[] qualifier = scvf.getQualifier();
          if (qualifier != null) {
            this.qualifier = Bytes.toString(Base64.getEncoder().encode(qualifier));
          }
          this.op = scvf.getCompareOperator().toString();
          this.comparator = new ByteArrayComparableModel(scvf.getComparator());
          if (scvf.getFilterIfMissing()) {
            this.ifMissing = true;
          }
          if (scvf.getLatestVersionOnly()) {
            this.latestVersion = true;
          }
        }
          break;
        case SkipFilter:
          this.filters = new ArrayList<>();
          this.filters.add(new FilterModel(((SkipFilter) filter).getFilter()));
          break;
        case TimestampsFilter:
          this.timestamps = ((TimestampsFilter) filter).getTimestamps();
          break;
        case WhileMatchFilter:
          this.filters = new ArrayList<>();
          this.filters.add(new FilterModel(((WhileMatchFilter) filter).getFilter()));
          break;
        case FuzzyRowFilter:
          this.fuzzyKeys = new ArrayList<>(((FuzzyRowFilter) filter).getFuzzyKeys().size());
          for (Pair<byte[], byte[]> keyWithMask : ((FuzzyRowFilter) filter).getFuzzyKeys()) {
            this.fuzzyKeys.add(new FuzzyKeyModel(keyWithMask));
          }
          break;
        default:
          throw new RuntimeException("unhandled filter type " + type);
      }
    }