Checks to see if the provided class is a control or property set interface that is
compatible with the local PropertyMap.
423556
private boolean isCompatibleClass(Class checkClass)
    {
        //
        // If the check class is equal to or a super-interface of the map class, then
        // they are compatible.
        //
        if (_mapClass.isAssignableFrom(checkClass))
            return true;

        //
        // If the check class is a property set declared by the map class or a super interface
        // of the map class, then they are compatible.
        //
        if (checkClass.isAnnotationPresent(PropertySet.class))
        {
            Class declaringClass = checkClass.getDeclaringClass();

            // External property sets are always compatible.
            // TODO: Could do a more extensive check..
            if (declaringClass == null)
                return true;

            if (declaringClass.isAssignableFrom(_mapClass))
                return true;
        }

        //
        // If the map class is a property set declared by the check class or a super interface
        // of the check class, then they are compatible.  This is the inverse of the last check,
        // and happens e.g. when a programatically instantiated control w/ an initial property
        // map needs to delegate to the control interface's property map.
        //
        if (_mapClass.isAnnotationPresent(PropertySet.class))
        {
            Class declaringClass = _mapClass.getDeclaringClass();
            if (declaringClass != null &&
                declaringClass.isAssignableFrom(checkClass))
                return true;

            // External property sets have no declaring class
            if (declaringClass == null)
            {
                ExternalPropertySets eps = (ExternalPropertySets) checkClass.getAnnotation(ExternalPropertySets.class);
                if (eps != null)
                {
                    Class[] propSets = eps.value();
                    if (propSets != null)
                    {
                        for (Class ps : propSets)
                        {
                            if (_mapClass.equals(ps))
                                return true;
                        }
                    }
                }
            }
        }

        return false;
    }
1049034
def IsPropertyInMetaIgnoreCase(classId, key):
		
		if classId in _ManagedObjectMeta:
			for prop in _ManagedObjectMeta[classId]:
				if (prop.lower() == key.lower()):
					return _ManagedObjectMeta[classId][prop]
		if classId in _MethodFactoryMeta:
			for prop in _MethodFactoryMeta[classId]:
				if (prop.lower() == key.lower()):
					return _MethodFactoryMeta[classId][prop]
		return None
923802
private static boolean isCompatibleClasses(final Class<?> one, final Class<?> two) {
        return one.isAssignableFrom(two) || two.isAssignableFrom(one);
    }
419972
public boolean compatible( PropertySet properties)
    {
    boolean isCompatible;
    Iterator<IDisjunct> disjuncts;
    
    for( disjuncts = getDisjuncts(),
           isCompatible = true;
           

         isCompatible
           && disjuncts.hasNext();

         isCompatible = disjuncts.next().compatible( properties));
    
    return isCompatible;
    }
1335025
public boolean compatible( PropertySet properties)
    {
    boolean isCompatible;
    Iterator<IAssertion> assertions;
    
    for( assertions = getAssertions(),
           isCompatible = !assertions.hasNext();

         !isCompatible
           && assertions.hasNext();

         isCompatible = assertions.next().compatible( properties));
    
    return isCompatible;
    }
848812
private boolean match(Class<?>[] declaredTypes, Class<?>[] actualTypes) {
        if (declaredTypes.length == actualTypes.length) {
            for (int i = 0; i < actualTypes.length; i++) {
                if (actualTypes[i] == NULL.class)
                    continue;

                if (wrapper(declaredTypes[i]).isAssignableFrom(wrapper(actualTypes[i])))
                    continue;

                return false;
            }

            return true;
        }
        else {
            return false;
        }
    }
955178
@SuppressWarnings("unchecked")
    private void fixGetSet(HashMap<String, HashMap> propertyTable) {

        if (propertyTable == null) {
            return;
        }

        for (Map.Entry<String, HashMap> entry : propertyTable.entrySet()) {
            HashMap<String, Object> table = entry.getValue();
            ArrayList<Method> getters = (ArrayList<Method>) table.get(STR_GETTERS);
            ArrayList<Method> setters = (ArrayList<Method>) table.get(STR_SETTERS);

            Method normalGetter = null;
            Method normalSetter = null;

            Class<?> normalPropType = null;

            if (getters == null) {
                getters = new ArrayList<>();
            }

            if (setters == null) {
                setters = new ArrayList<>();
            }

            // retrieve getters
            Class<?>[] paramTypes;
            String methodName;
            for (Method getter : getters) {
                paramTypes = getter.getParameterTypes();
                methodName = getter.getName();
                // checks if it's a normal getter
                if (paramTypes == null || paramTypes.length == 0) {
                    // normal getter found
                    if (normalGetter == null || methodName.startsWith(PREFIX_IS)) {
                        normalGetter = getter;
                    }
                }
            }

            // retrieve normal setter
            if (normalGetter != null) {
                // Now we will try to look for normal setter of the same type.
                Class<?> propertyType = normalGetter.getReturnType();

                for (Method setter : setters) {
                    if (setter.getParameterTypes().length == 1
                        && propertyType.equals(setter.getParameterTypes()[0])) {
                        normalSetter = setter;
                        break;
                    }
                }
            } else {
                // Normal getter wasn't defined. Let's look for the last
                // defined setter

                for (Method setter : setters) {
                    if (setter.getParameterTypes().length == 1) {
                        normalSetter = setter;
                    }
                }
            }

            // determine property type
            if (normalGetter != null) {
                normalPropType = normalGetter.getReturnType();
            } else if (normalSetter != null) {
                normalPropType = normalSetter.getParameterTypes()[0];
            }

            // RULES
            // These rules were created after performing extensive black-box
            // testing of RI

            // RULE1
            // Both normal getter and setter of the same type were defined;
            // no indexed getter/setter *PAIR* of the other type defined
            if (normalGetter != null && normalSetter != null) {
                table.put(STR_NORMAL, STR_VALID);
                table.put(STR_NORMAL + PREFIX_GET, normalGetter);
                table.put(STR_NORMAL + PREFIX_SET, normalSetter);
                table.put(STR_NORMAL + STR_PROPERTY_TYPE, normalPropType);
                continue;
            }

            // RULE2
            // normal getter and/or setter was defined; no indexed
            // getters & setters defined
            if ((normalGetter != null || normalSetter != null)) {
                table.put(STR_NORMAL, STR_VALID);
                table.put(STR_NORMAL + PREFIX_GET, normalGetter);
                table.put(STR_NORMAL + PREFIX_SET, normalSetter);
                table.put(STR_NORMAL + STR_PROPERTY_TYPE, normalPropType);
                continue;
            }

            // default rule - invalid property
            table.put(STR_NORMAL, STR_INVALID);
        }
    }
738714
public static boolean isListSetMap(String clsName) throws ClassNotFoundException {
        JavaClass cls = Repository.lookupClass(clsName);
        return (cls.implementationOf(LIST_CLASS) || cls.implementationOf(SET_CLASS) || cls.implementationOf(MAP_CLASS));
    }
59751
public static boolean isIntrospectable(final Class<?> type) {
        return !isEnumType(type)
                && !isArrayType(type)
                && !(isCollectionType(type) && isJdkBuiltIn(type))
                && !(isMapType(type) && isJdkBuiltIn(type));
    }
1248359
function isKeyValueProperty(property) {
            return !(
                (property.method ||
                property.shorthand ||
                property.kind !== "init" || property.type !== "Property") // Could be "ExperimentalSpreadProperty" or "SpreadElement"
            );
        }
35728
boolean matchSourceClass(String destination) {
    for (String token: propertyNameInfo.getSourceClassTokens())
      if (token.equalsIgnoreCase(destination))
        return true;
    return false;
  }
370192
private static boolean isValidPropertyClass(final PropertyDescriptor _property) {
        final Class type = _property.getPropertyType();
        return Number.class.isAssignableFrom(type) || type == String.class || Date.class.isAssignableFrom(type) || type == Boolean.class;
    }
635193
@Override
    public int isCompatible(Class<?> target, Object actual) {
        int superCompat = super.isCompatible(target, actual);
        if (superCompat >= 0 && superCompat < 3) {
            return superCompat;
        }

        Class<?> actualClass = actual.getClass();
        if (actualClass == Types.UNDEFINED.getClass() || actualClass == Types.NULL.getClass()) {
            return 3;
        }

        if (JSFunction.class.isAssignableFrom(actualClass)) {
            if (isSingleAbstractMethod(target) != null) {
                return 3;
            }
        }

        return -1;
    }
1085113
public void visitPropertyMap(PropertyMap<S, D> propertyMap) {
    String propertyMapClassName = propertyMap.getClass().getName();

    try {
      ClassReader cr = new ClassReader(propertyMap.getClass().getClassLoader().getResourceAsStream(
          propertyMapClassName.replace('.', '/') + ".class"));
      ExplicitMappingVisitor visitor = new ExplicitMappingVisitor(errors, configuration,
          propertyMapClassName, destinationType.getName(), propertyMap.getClass().getClassLoader());
      cr.accept(visitor, ClassReader.SKIP_FRAMES | ClassReader.SKIP_DEBUG);
      visitedMappings = visitor.mappings;
    } catch (IOException e) {
      errors.errorReadingClass(e, propertyMapClassName);
    }

    errors.throwConfigurationExceptionIfErrorsExist();
    createProxies();
  }
1116405
public final boolean isPropertyTypeDeclared(String propertyName) {
    StaticTypedSlot slot = getSlot(propertyName);
    return slot == null ? false : !slot.isTypeInferred();
  }
199683
private boolean isPropertyTypeInternal() {
        Class<?> type = getType();
        return
                // References are always contained in properties of type String or String[].
                isReference()
                        || isPropertyType(type)
                        || (type.isArray() || isCollectionType) && isPropertyType(getTypeParameter());
    }
1189903
public boolean isAssignableFrom(JClass cl)
  {
    if (getName().equals(cl.getName()))
      return true;

    JClass []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;
  }