auto kernel_specs_it = specs_.find(kernel);
  if (kernel_specs_it == specs_.end()) return std::nullopt;
  return kernel_specs_it->getValue().Find(signature);
}

ScaleDecomposeFn DeviceTarget::GetDecomposeFn(
    quantfork::QuantizeRegionOp op) const {
  auto kernel_specs_it = specs_.find(op.getLogicalKernel());
  if (kernel_specs_it == specs_.end()) return ScaleDecomposeFn(nullptr);

  ScaleDecomposeFn GetDecomposeFn() const { return decompose_fn_; }

  // Adds the kernel signature with the kernel specification.
  LogicalResult Add(const Signature& signature, const KernelSpec& spec) {
    if (all_signatures_.insert({signature, spec}).second) return success();
    return failure();
  }

  KernelSpecs& WithSignature(const KernelSpecs::Signature& signature,
                             const ScaleFn& fn) {

  GraphImportConfig specs;
  specs.graph_func_name = name;
  specs.prune_unused_nodes = true;
  TF_ASSIGN_OR_RETURN(specs.inputs, ParseInputArrays(inputs));
  for (auto& output : outputs) {
    TF_ASSIGN_OR_RETURN(std::string name,
                        GetDenseTensorNameFromTensorInfo(output.second));
    specs.outputs.push_back(std::move(name));
  }
  specs.control_outputs = control_outputs;

     */
    public static <T> Spec<T> intersect(Collection<? extends Spec<? super T>> specs) {
        if (specs.size() == 0) {
            return satisfyAll();
        }
        return doIntersect(specs);
    }

    private static <T> Spec<T> doIntersect(Collection<? extends Spec<? super T>> specs) {
        List<Spec<? super T>> filtered = new ArrayList<>(specs.size());
        for (Spec<? super T> spec : specs) {

        return doIntersect(specs);
    }

    private static <T> Spec<T> doIntersect(Collection<? extends Spec<T>> specs) {
        List<Spec<T>> filtered = new ArrayList<Spec<T>>(specs.size());
        for (Spec<T> spec : specs) {
            if (spec == SATISFIES_NONE) {
                return satisfyNone();
            }
            if (spec != SATISFIES_ALL) {
                filtered.add(spec);
            }
        }

 * limitations under the License.
 */

package org.gradle.internal;

import org.gradle.api.specs.Spec;

public class Specs {
    public static <T> Spec<T> isInstance(final Class<?> type) {
        return new Spec<T>() {
            @Override
            public boolean isSatisfiedBy(T element) {
                return type.isInstance(element);
            }
        };

        def spec1 = Stub(Spec)
        def spec2 = Stub(Spec)

        expect:
        Specs.union(spec1, Specs.satisfyNone(), spec2).specs == [spec1, spec2]
        Specs.union([spec1, Specs.satisfyNone(), spec2]).specs == [spec1, spec2]
        Specs.union(spec1, Specs.satisfyNone()) == spec1
        Specs.union([spec1, Specs.satisfyNone()]) == spec1

        assert createCompositeSpec(spec2, spec1).equals(createCompositeSpec(spec2, spec1));
        assertFalse(createCompositeSpec(spec1, spec2).equals(createCompositeSpec(spec2, spec1)));

        assertFalse(createCompositeSpec(spec1).equals(createOtherCompositeSpec(spec1)));
        assertFalse(createCompositeSpec(spec2).equals(createOtherCompositeSpec(spec2)));

        def spec1 = Mock(ClassLoaderSpec)
        def spec2 = Mock(ClassLoaderSpec)
        def spec3 = Mock(ClassLoaderSpec)
        def spec4 = Mock(ClassLoaderSpec)
        def settings1 = daemonForkOptionsBuilder()
                .withClassLoaderStructure(new HierarchicalClassLoaderStructure(spec1).withChild(spec2).withChild(spec3))
                .build()

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.specs;

/**
 * Represents some predicate against objects of type T.
 *
 * @param <T> The target type for this Spec
 */
public interface Spec<T> {
    boolean isSatisfiedBy(T element);