Check if a given object is instance of the type of this bean spec.

@param o
the object instance
@return `true` if the object is an instance of type of this bean spec
337086
public boolean isInstance(Object o) {
        Class c = rawType();
        if (c.isInstance(o)) {
            return true;
        }
        Class p = $.primitiveTypeOf(c);
        if (null != p && p.isInstance(o)) {
            return true;
        }
        Class w = $.wrapperClassOf(c);
        if (null != w && w.isInstance(o)) {
            return true;
        }
        return false;
    }
503978
public static boolean isInstanceOf(Object obj, String classSimpleName) {
    if (obj == null) {
      return false;
    }
    
    Class<?> currentClass = obj.getClass();
    while (currentClass != Object.class) {
      if (currentClass.getSimpleName().equals(classSimpleName)) {
        return true;
      } else {
        currentClass = currentClass.getSuperclass();
      }
    }
    return false;
  }
38566
function isInstance(node) {
  if (node.type === 'Identifier') {
    if (currentOptions.angular) {
      if (instanceVarsRegExp.angular.test(node.name)) {
        return true;
      }
    } else {
      if (instanceVarsRegExp.noangular.test(node.name)) {
        return true;
      }
    }
  }
  if (node.type === 'CallExpression') {
    if (isConstructor(node.callee)) {
      return true;
    }
    if (node.callee.type === 'MemberExpression') {
      if (isInstance(node.callee.object)) {
        if (node.callee.property.type === 'Identifier' &&
            constants.METHODS.CHAIN.indexOf(node.callee.property.name) !== -1) {
          return true;
        }
      }
    }
  }
  return false;
}
369374
public boolean equalsContents(Object o) {
        if(this == o) {
            return true;
        }
        if(o == null) {
            return false;
        }
        if (o.getClass() != getClass()) {
            return false;
        }

        if(!super.equalsContents(o)) {
            return false;
        }

        Referenceable obj = (Referenceable)o;
        if (!traitNames.equals(obj.getTraits())) {
            return false;
        }

        return true;
    }
963240
function isBoolean(o) {
    return o !== undefined && o !== null &&
          (typeof o === "boolean" || o.constructor === Boolean);
}
409230
public static boolean isInvalid(Object bean) {
		if (bean == null) {
			return false;
		}
		return isPrimitiveOrWrapper(bean.getClass()) 
				|| INVALID_TYPES.contains(bean.getClass())
				|| isInstanceOfInvalid(bean.getClass());
	}
868894
public Criteria is(Object o) {
        this.criteriaType = RelationalOperator.EQ;
        this.right = ValueNode.toValueNode(o);
        return this;
    }
658289
@Override
    public boolean isEqual(Object o) {
        if (o == this) {
            return true;
        }
        if (!(o instanceof AbstractParameter)) {
            return false;
        }

        AbstractParameter a = (AbstractParameter) o;
        Granularity startGranularity = getInterval().getStartGranularity();
        Granularity aStartGranularity = a.getInterval().getStartGranularity();
        Granularity finishGranularity = getInterval().getFinishGranularity();
        Granularity aFinishGranularity = a.getInterval().getFinishGranularity();
        return super.isEqual(a)
                && (startGranularity == aStartGranularity || (startGranularity != null && startGranularity
                        .equals(aStartGranularity)))
                && (finishGranularity == aFinishGranularity || (finishGranularity != null && finishGranularity
                        .equals(aFinishGranularity)))
                && (this.contextId == a.contextId || (this.contextId != null && this.contextId.equals(a.contextId)));
    }
452378
public static boolean typesMatch(ParaObject so) {
		return (so == null) ? false : so.getClass().equals(toClass(so.getType()));
	}
1155000
@SuppressWarnings("unchecked")
	public T getInstance() {
		if(beanClassName == null) {
			return null;
		} else try {
			T beanInstance;
			Class<T> beanClass = null;
			try {
				try {
					ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
					beanClass = (Class<T>)Class.forName(beanClassName, true, classLoader);
				} catch(ClassNotFoundException cnfe) {
					throw new RuntimeException("Unknown class " + beanClassName, cnfe);
				}
				// Instancjonowanie i inicjalizcja w oparciu o konstruktor inicjujący:
				Constructor<T> constructor = (Constructor<T>)beanClass.getConstructor(Collection.class);
				beanInstance = constructor.newInstance(properties);
			} catch(NoSuchMethodException nsme) {
				// Instancjonowanie i inicjalizacja w oparciu o konstruktor bezargumentowy
				// i publiczne setter'y Java Beans:
				beanInstance = beanClass.newInstance();

				if(properties != null && !properties.isEmpty()) {
					BeanInfo validatorInfo = Introspector.getBeanInfo(beanClass);
					PropertyDescriptor[] propertyDescriptors = validatorInfo.getPropertyDescriptors();
					for(BeanProperty beanProperty : properties) {
						String propertyName = beanProperty.getPropertyName();
						Method writeMethod = null;
						for(PropertyDescriptor propertyDescriptor : propertyDescriptors) {
							if(propertyDescriptor.getName().equals(propertyName)) {
								writeMethod = propertyDescriptor.getWriteMethod();
								break;
							}
						}
						if(writeMethod == null) {
							throw new RuntimeException("No public setter found for property '" + propertyName + "' "
									+ "in validator class " + beanClass.getCanonicalName());
						}
						Class<?> parameterType = writeMethod.getParameterTypes()[0];
						if(BeanProperty.class.equals(parameterType)) {
							writeMethod.invoke(beanInstance, beanProperty);
						} else if(String.class.equals(parameterType)) {
							if(beanProperty.hasAttributes()) {
								throw new RuntimeException("BeanProperty '" + propertyName + "' setter should has "
										+ Parameter.class.getSimpleName() + " type parameter");
							}
							writeMethod.invoke(beanInstance, beanProperty.getPropertyValue());
						}
					}
				}
			}
			return beanInstance;
		} catch(Exception e) {
			throw new RuntimeException(e);
		}
	}
753371
public static function isClassInstance($object, $class_name)
    {
        if (class_exists($class_name) && is_object($object)) {
            return (bool) ($object instanceof $class_name);
        }
        return false;
    }
105680
public boolean equalsTo(Object o)
    {
        if(o == null || !(o instanceof Reference))
        {
            return false;
        }
        
        Reference refCompared = (Reference)o;
        if(!StringUtil.isEquals(sections, refCompared.sections)) return false;
        if(systemUnderTest == null || !systemUnderTest.equalsTo(refCompared.systemUnderTest)) return false;
        if(requirement == null || !requirement.equalsTo(refCompared.requirement)) return false;
        if(specification == null || !specification.equalsTo(refCompared.specification)) return false;
        
        return true;
    }
611002
def object_isinstance(node, class_or_seq, context=None):
    
    obj_type = object_type(node, context)
    if obj_type is util.Uninferable:
        return util.Uninferable
    return _object_type_is_subclass(obj_type, class_or_seq, context=context)
833648
public boolean isToClass(Class<?> toClass) {
        List<DomainClass> domainClasses = reflectionHelper.getAnnotationWithMeta(toClass, DomainClass.class);
        return 0 != domainClasses.size();
    }
846398
def is_instance_or_subclass(val, class_):
    """"""
    try:
        return issubclass(val, class_)
    except TypeError:
        return isinstance(val, class_)
1077078
def is_object_type(type_):
    

    object_types = _get_types(Types.OBJECT)
    if is_typing_type(type_):
        return type_ in object_types or (
            hasattr(type_, "__origin__") and type_.__origin__ in object_types
        )
    return type_ in object_types
78604
public static boolean isPropertyInitialized(Object object) {
    	Class < ? > cl =  getHibernateClass();
    	
        if (cl == null) {
            return true;
        }
        
        Method method = getInitializeMethod(cl);
        return checkInitialize(method, object);
    }