This is the environment implementation of
        :meth:`BaseLayer.isCompatible`.

        Subclasses may override this method.
16198
def _isCompatible(self, other, reporter):
        
        layer1 = self
        layer2 = other

        # incompatible number of glyphs
        glyphs1 = set(layer1.keys())
        glyphs2 = set(layer2.keys())
        if len(glyphs1) != len(glyphs2):
            reporter.glyphCountDifference = True
            reporter.warning = True
        if len(glyphs1.difference(glyphs2)) != 0:
            reporter.warning = True
            reporter.glyphsMissingFromLayer2 = list(glyphs1.difference(glyphs2))
        if len(glyphs2.difference(glyphs1)) != 0:
            reporter.warning = True
            reporter.glyphsMissingInLayer1 = list(glyphs2.difference(glyphs1))
        # test glyphs
        for glyphName in sorted(glyphs1.intersection(glyphs2)):
            glyph1 = layer1[glyphName]
            glyph2 = layer2[glyphName]
            glyphCompatibility = glyph1.isCompatible(glyph2)[1]
            if glyphCompatibility.fatal or glyphCompatibility.warning:
                if glyphCompatibility.fatal:
                    reporter.fatal = True
                if glyphCompatibility.warning:
                    reporter.warning = True
                reporter.glyphs.append(glyphCompatibility)
1276916
def is_compatible(self):
        ''''''
        supported_tags = pep425tags.get_supported()
        return next((True for t in self.tags() if t in supported_tags), False)
1350496
function checkCompatible(type, modulePath, location) {
    var adapterPackage = require(path.join(modulePath, 'package.json'));
    var adapterJuttleVersion = adapterPackage.juttleAdapterAPI;
    if (!adapterJuttleVersion) {
        throw errors.compileError('INCOMPATIBLE-ADAPTER', {
            type,
            adapterJuttleVersion: '(unknown)',
            apiVersion: JuttleAdapterAPI.version,
            location
        });
    }

    if (!semver.satisfies(JuttleAdapterAPI.version, adapterJuttleVersion)) {
        throw errors.compileError('INCOMPATIBLE-ADAPTER', {
            type,
            adapterJuttleVersion,
            apiVersion: JuttleAdapterAPI.version,
            location
        });
    }
}
1106745
private static boolean isCompatible(ArgumentMatcher<?> argumentMatcher, Object argument) {
        if (argument == null)
            return true;

        Class<?> expectedArgumentType = getArgumentType(argumentMatcher);

        return expectedArgumentType.isInstance(argument);
    }
7948
public boolean isAssignableFrom(Class cl)
  {
    if (getName().equals(cl.getName()))
      return true;

    Class []ifc = cl.getInterfaces();

    for (int i = 0; i < ifc.length; i++) {
      if (isAssignableFrom(ifc[i]))
        return true;
    }

    if (cl.getSuperclass() != null)
      return isAssignableFrom(cl.getSuperclass());
    else
      return false;
  }
501146
private static <T> boolean newPojoSerializerIsCompatibleWithReconfiguredSerializer(
			PojoSerializer<T> newPojoSerializer,
			IntermediateCompatibilityResult<T> fieldSerializerCompatibility,
			IntermediateCompatibilityResult<T> preExistingRegistrationsCompatibility,
			LinkedOptionalMap<Class<?>, TypeSerializerSnapshot<?>> registeredSubclassSerializerSnapshots,
			LinkedOptionalMap<Class<?>, TypeSerializerSnapshot<?>> nonRegisteredSubclassSerializerSnapshots) {
		return newPojoHasDifferentSubclassRegistrationOrder(registeredSubclassSerializerSnapshots, newPojoSerializer)
			|| previousSerializerHasNonRegisteredSubclasses(nonRegisteredSubclassSerializerSnapshots)
			|| fieldSerializerCompatibility.isCompatibleWithReconfiguredSerializer()
			|| preExistingRegistrationsCompatibility.isCompatibleWithReconfiguredSerializer();
	}
192324
public static boolean isAssignable(TypeName typeName, Class<?> assignableClazz) {
		try {
			if (typeName instanceof ParameterizedTypeName) {
				typeName = ((ParameterizedTypeName) typeName).rawType;
			} else if (typeName instanceof ArrayTypeName) {
				typeName = ((ArrayTypeName) typeName).componentType;
			}

			Class<?> resolvedType = Class.forName(typeName.toString());
			return assignableClazz.isAssignableFrom(resolvedType);
		} catch (ClassNotFoundException e) {
			return false;
		}
	}
1059114
def compatible(self, a, b):
        """"""
        return len(set([a] + self.descendants(a))
                   .intersection([b] + self.descendants(b))) > 0
1032502
public static boolean isCompatible(Class<?> c, Object o) {
		boolean pt = c.isPrimitive();
		if (o == null)
			return !pt;

		if (pt) {
			if (c == int.class)
				c = Integer.class;
			else if (c == boolean.class)
				c = Boolean.class;
			else if (c == long.class)
				c = Long.class;
			else if (c == float.class)
				c = Float.class;
			else if (c == double.class)
				c = Double.class;
			else if (c == char.class)
				c = Character.class;
			else if (c == byte.class)
				c = Byte.class;
			else if (c == short.class)
				c = Short.class;
		}
		if (c == o.getClass())
			return true;
		return c.isInstance(o);
	}
488909
@Override
    public boolean isEligibleFor(Object criterion) {
        return Class.class.isInstance(criterion)
            && ((Class<?>) criterion).isAssignableFrom(getClass());
    }
687113
private static boolean isAssignableFrom(ParameterizedType type1, Class<?> type2) {
        Class<?> rawType1 = Reflections.getRawType(type1);

        // raw types have to be assignable
        if (!isAssignableFrom(rawType1, type2)) {
            return false;
        }
        // this is a raw type with missing type arguments
        if (!Types.getCanonicalType(type2).equals(type2)) {
            return true;
        }

        return matches(type1, new HierarchyDiscovery(type2));
    }
229973
def _isCompatible(self, other, reporter):
        
        font1 = self
        font2 = other

        # incompatible guidelines
        guidelines1 = set(font1.guidelines)
        guidelines2 = set(font2.guidelines)
        if len(guidelines1) != len(guidelines2):
            reporter.warning = True
            reporter.guidelineCountDifference = True
        if len(guidelines1.difference(guidelines2)) != 0:
            reporter.warning = True
            reporter.guidelinesMissingFromFont2 = list(
                guidelines1.difference(guidelines2))
        if len(guidelines2.difference(guidelines1)) != 0:
            reporter.warning = True
            reporter.guidelinesMissingInFont1 = list(
                guidelines2.difference(guidelines1))
        # incompatible layers
        layers1 = set(font1.layerOrder)
        layers2 = set(font2.layerOrder)
        if len(layers1) != len(layers2):
            reporter.warning = True
            reporter.layerCountDifference = True
        if len(layers1.difference(layers2)) != 0:
            reporter.warning = True
            reporter.layersMissingFromFont2 = list(layers1.difference(layers2))
        if len(layers2.difference(layers1)) != 0:
            reporter.warning = True
            reporter.layersMissingInFont1 = list(layers2.difference(layers1))
        # test layers
        for layerName in sorted(layers1.intersection(layers2)):
            layer1 = font1.getLayer(layerName)
            layer2 = font2.getLayer(layerName)
            layerCompatibility = layer1.isCompatible(layer2)[1]
            if layerCompatibility.fatal or layerCompatibility.warning:
                if layerCompatibility.fatal:
                    reporter.fatal = True
                if layerCompatibility.warning:
                    reporter.warning = True
                reporter.layers.append(layerCompatibility)
816912
function checkCompatibility() {
        // We use JSON for serialization. http://caniuse.com/#feat=json
        if (! window.JSON) {
            return false;
        }

        // For now, we require jQuery.
        // In the future, we may build adaptors for other libraries
        if (! window.jQuery) {
            return false;
        }

        // We require jQuery >= 1.7, because of `.on`
        if (jQuery().jquery <= '1.7') {
            return false;
        }

        // Otherwise, we are good
        return true;
    }
923565
public boolean isCompatibleWith(DataType other) {
        // A type is compatible with a choice type if it is a subtype of one of the choice types
        if (other instanceof ChoiceType) {
            for (DataType choice : ((ChoiceType)other).getTypes()) {
                if (this.isSubTypeOf(choice)) {
                    return true;
                }
            }
        }

        return this.equals(other); // Any data type is compatible with itself
    }
765077
def _is_compatible_with(self, other):
        

        title = self._compare_title(other)
        suffix = self._compare_suffix(other)

        return title and suffix
923802
private static boolean isCompatibleClasses(final Class<?> one, final Class<?> two) {
        return one.isAssignableFrom(two) || two.isAssignableFrom(one);
    }
1192908
private static boolean isAssignableFrom(Type from, GenericArrayType to) {
		Type toGenericComponentType = to.getGenericComponentType();
		if (toGenericComponentType instanceof ParameterizedType) {
			Type t = from;
			if (from instanceof GenericArrayType) {
				t = ((GenericArrayType) from).getGenericComponentType();
			} else if (from instanceof Class) {
				Class<?> classType = (Class<?>) from;
				while (classType.isArray()) {
					classType = classType.getComponentType();
				}
				t = classType;
			}
			return isAssignableFrom(t,
					(ParameterizedType) toGenericComponentType,
					new HashMap<String, Type>());
		}
		// No generic defined on "to"; therefore, return true and let other
		// checks determine assignability
		return true;
	}