Static constructor for a not supported status caused by sub-filters not being supported.

@param unsupportedSubfilters a {@link java.util.List} object.
@return a {@link com.google.cloud.bigtable.hbase.adapters.filters.FilterSupportStatus} object.
484276
public static FilterSupportStatus newCompositeNotSupported(
      List<FilterSupportStatus> unsupportedSubfilters) {
    StringBuilder builder = new StringBuilder();
    for (FilterSupportStatus subStatus: unsupportedSubfilters) {
      builder.append(subStatus.getReason());
      builder.append("\n");
    }
    return new FilterSupportStatus(false, builder.toString());
  }
601329
public static void unsupportedIfNot(boolean tester, String msg, Object ... args) {
        if (!tester) {
            throw unsupport(msg, args);
        }
    }
781354
public boolean isBloomFilteringSupported() {
        if (clientVersion >= params.getProtocolVersionNum(NetworkParameters.ProtocolVersion.BLOOM_FILTER)
                && clientVersion < params.getProtocolVersionNum(NetworkParameters.ProtocolVersion.BLOOM_FILTER_BIP111))
            return true;
        if ((localServices & NODE_BLOOM) == NODE_BLOOM)
            return true;
        return false;
    }
726972
public function addFilter(FilterInterface $filter)
    {
        if (! ($this->resource instanceof ImageFilterableInterface)) {
            throw new UnsupportedMethodException("This method is not supported by the ImageResource in use.");
        }

        $this->getFilterResolver()->addFilter($filter);

        return $this;
    }
247245
public AerospikeDeepJobConfig<T> filterQuery(Filter[] filters) {
        if (filters.length > 1) {
            throw new UnsupportedOperationException("Aerospike currently accepts only one filter operations");
        } else if (filters.length > 0) {
            Filter deepFilter = filters[0];
            if (!isValidAerospikeFilter(deepFilter)) {
                throw new UnsupportedOperationException(
                        "Aerospike currently supports only equality and range filter operations");
            } else if (!deepFilter.getFilterType().equals(FilterType.EQ)) {
                operation("numrange");
                setAerospikeNumrange(deepFilter);
            } else {
                operation("scan");
                setAerospikeEqualsFilter(deepFilter);
            }
        }
        return this;
    }
778818
private List<WorkUnit> materializeWorkUnitList(WorkUnitStream workUnitStream) {
    if (!workUnitStream.isFiniteStream()) {
      throw new UnsupportedOperationException("Cannot materialize an infinite work unit stream.");
    }
    return Lists.newArrayList(workUnitStream.getWorkUnits());
  }
1173505
List<IntArrayList> findSubnetworks(PrepEdgeFilter filter) {
        final BooleanEncodedValue accessEnc = filter.getAccessEnc();
        final EdgeExplorer explorer = ghStorage.createEdgeExplorer(filter);
        int locs = ghStorage.getNodes();
        List<IntArrayList> list = new ArrayList<>(100);
        final GHBitSet bs = new GHBitSetImpl(locs);
        for (int start = 0; start < locs; start++) {
            if (bs.contains(start))
                continue;

            final IntArrayList intList = new IntArrayList(20);
            list.add(intList);
            new BreadthFirstSearch() {
                int tmpCounter = 0;

                @Override
                protected GHBitSet createBitSet() {
                    return bs;
                }

                @Override
                protected final boolean goFurther(int nodeId) {
                    if (tmpCounter > maxEdgesPerNode.get())
                        maxEdgesPerNode.set(tmpCounter);

                    tmpCounter = 0;
                    intList.add(nodeId);
                    return true;
                }

                @Override
                protected final boolean checkAdjacent(EdgeIteratorState edge) {
                    if (edge.get(accessEnc) || edge.getReverse(accessEnc)) {
                        tmpCounter++;
                        return true;
                    }
                    return false;
                }

            }.start(explorer, start);
            intList.trimToSize();
        }
        return list;
    }
1038414
protected boolean loadFilters(final boolean cleanOnFail, boolean asynchronous)
   {
      if (!filtersSupported.get())
      {
         if (LOG.isWarnEnabled())
         {
            LOG.warn("The bloom filters are not supported therefore they cannot be reloaded");
         }
         return false;
      }
      filtersEnabled.set(false);
      this.filterPermissions = new BloomFilter<String>(bfProbability, bfElementNumber);
      this.filterOwner = new BloomFilter<String>(bfProbability, bfElementNumber);

      if (asynchronous)
      {
         new Thread(new Runnable()
         {
            public void run()
            {
               doLoadFilters(cleanOnFail);
            }
         }, "BloomFilter-Loader-" + dataContainer.getName()).start();

         return true;
      }
      else
      {
         return doLoadFilters(cleanOnFail);
      }
   }
16994
public UnsupportedOperationException asJDKException() {
        UnsupportedOperationException e = new UnsupportedOperationException(getMessage()) {
            @Override
            public synchronized Throwable fillInStackTrace() {
                return this;
            }
        };
        e.setStackTrace(getStackTrace());
        return e;
    }
523499
@Override
    public List<SearchResult> searchInInvertedIndex(String columnFamilyName, EntityMetadata m,
        Map<Boolean, List<IndexClause>> indexClauseMap) {
        throw new UnsupportedOperationException("Support available only for thrift/pelops.");
    }
796421
@Override
    protected List<SuperColumn> loadSuperColumns(String keyspace, String columnFamily, String rowId,
        String... superColumnNames) {
        throw new UnsupportedOperationException(
            "Support for super columns is not available with DS java driver. Either use Thrift or pelops for the same");
    }
157475
public BuiltinSlotTypeMetadata withSupportedLocales(Locale... supportedLocales) {
        java.util.ArrayList<String> supportedLocalesCopy = new java.util.ArrayList<String>(supportedLocales.length);
        for (Locale value : supportedLocales) {
            supportedLocalesCopy.add(value.toString());
        }
        if (getSupportedLocales() == null) {
            setSupportedLocales(supportedLocalesCopy);
        } else {
            getSupportedLocales().addAll(supportedLocalesCopy);
        }
        return this;
    }
779928
protected List<MediaType> getAllSupportedMediaTypes(List<HttpMessageConverter<?>> messageConverters) {
        Set<MediaType> allSupportedMediaTypes = new LinkedHashSet<MediaType>();
        for (HttpMessageConverter<?> messageConverter : messageConverters) {
            allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
        }

        List<MediaType> result = new ArrayList<MediaType>(allSupportedMediaTypes);

        MediaType.sortBySpecificity(result);

        return Collections.unmodifiableList(result);
    }
1183082
@Override
    public CriteriaBuilder getCriteriaBuilder()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "getCriteriaBuilder : " + this);
        throw new UnsupportedOperationException("This operation is not supported on a pooling EntityManagerFactory.");
    }
390445
@Override
    public WritableBlobContainerContract withResponseFilterFirst(
            ServiceResponseFilter serviceResponseFilter) {
        MediaBlobContainerWriter mediaBlobContainerWriter = new MediaBlobContainerWriter(
                this);
        mediaBlobContainerWriter.setBlobContract(mediaBlobContainerWriter
                .getBlobContract().withResponseFilterFirst(
                        serviceResponseFilter));
        return mediaBlobContainerWriter;
    }
49526
private <R> R notSupportedInternal(final SQLSupplier<R> supplier) {
		Optional<LocalTransactionContext> txContext = currentTxContext();
		if (txContext.isPresent()) {
			// トランザクションをサスペンド
			LocalTransactionContext txContextValue = this.txCtxStack.pop();
			try {
				return supplier.get();
			} finally {
				//戻す
				this.txCtxStack.push(txContextValue);
			}
		} else {
			return supplier.get();
		}
	}
248765
public static void unsupportedIf(boolean tester, String msg, Object ... args) {
        if (tester) {
            throw unsupport(msg, args);
        }
    }