return true if is use a bean (that this dao manage) as parameter.

@return return true if is use a bean (that this dao manage) as parameter.
351941
public boolean hasBeanAsParameter() {
		TypeName entityTypeName = TypeUtility.typeName(this.getEntity().getElement());

		for (Pair<String, TypeName> item : this.parameters) {
			if (item.value1.equals(entityTypeName)) {
				return true;
			}
		}

		return false;
	}
1085018
private boolean isIdCol(EntityMetadata m, String colName)
    {
        return ((AbstractAttribute) m.getIdAttribute()).getJPAColumnName().equals(colName);
    }
737720
public synchronized boolean hasService(Class serviceClass) {

        // todo: for multithreaded usage this block needs to be synchronized
        ServiceProvider sp = _serviceProviders.get(serviceClass);
        if (sp != null && !sp.isRevoked()) {
            return true;
        }

        // if service not found locally check in nested context
        BeanContext bc = getBeanContext();
        if (bc instanceof BeanContextServices) {
            return ((BeanContextServices) bc).hasService(serviceClass);
        }
        return false;
        // end synchronized
    }
109656
private boolean hasRegisterMapper(Class<?> mapperInterface){
        //如果一个都没匹配上，很可能是还没有注册 mappers，此时通过 @RegisterMapper 注解进行判断
        Class<?>[] interfaces = mapperInterface.getInterfaces();
        boolean hasRegisterMapper = false;
        if (interfaces != null && interfaces.length > 0) {
            for (Class<?> anInterface : interfaces) {
                //自动注册标记了 @RegisterMapper 的接口
                if(anInterface.isAnnotationPresent(RegisterMapper.class)){
                    hasRegisterMapper = true;
                    //如果已经注册过，就避免在反复调用下面会迭代的方法
                    if (!registerMapper.containsKey(anInterface)) {
                        registerMapper(anInterface);
                    }
                }
                //如果父接口的父接口存在注解，也可以注册
                else if(hasRegisterMapper(anInterface)){
                    hasRegisterMapper = true;
                }
            }
        }
        return hasRegisterMapper;
    }
1045847
private boolean setupManyNesting() {
        BeanAttributeInformation parentAttribute = null;
        BeanAttributeInformation idAttribute = null;
        BeanInformation beanInformation = BeanInformation.get(idField.getType());
        for (String attributeName : beanInformation.getAttributeNames()) {
            BeanAttributeInformation attribute = beanInformation.getAttribute(attributeName);
            if (attribute.getAnnotation(JsonApiRelationId.class).isPresent()) {
                PreconditionUtil.verify(parentAttribute == null,
                        "nested identifiers can only have a single @JsonApiRelationId annotated field, got multiple for %s",
                        beanInformation.getImplementationClass());
                parentAttribute = attribute;
            } else if (attribute.getAnnotation(JsonApiId.class).isPresent()) {
                PreconditionUtil.verify(idAttribute == null,
                        "nested identifiers can only one attribute being annotated with @JsonApiId, got multiple for %s",
                        beanInformation.getImplementationClass());
                idAttribute = attribute;
            }
        }

        if (parentAttribute != null || idAttribute != null) {
            if (!shouldBeNested()) {
                LOGGER.warn("add @JsonApiResource(nested=true) to {} to mark it as being nested, in the future automatic discovery based on the id will be removed",
                        implementationClass);
            }

            PreconditionUtil.verify(idAttribute != null,
                    "nested identifiers must have attribute annotated with @JsonApiId, got none for %s",
                    beanInformation.getImplementationClass());
            PreconditionUtil.verify(parentAttribute != null,
                    "nested identifiers must have attribute annotated with @JsonApiRelationId, got none for %s",
                    beanInformation.getImplementationClass());
            String relationshipName = parentAttribute.getName().substring(0, parentAttribute.getName().length() - 2);

            // accessors for nested and parent id, able to deal with both resources and identifiers as parameters
            this.parentIdAccessor = new NestedIdAccessor(parentAttribute);
            this.childIdAccessor = new NestedIdAccessor(idAttribute);

            // check whether parentField is duplicated in ID. This can be a valid use case if the nested identifier is considered
            // an add-on to an existing object.
            String parentName = parentAttribute.getName();
            Optional<ResourceField> optParentField = relationshipFields.stream().filter(it -> it.hasIdField() && it.getIdName().equals(parentName)).findFirst();
            if (optParentField.isPresent()) {
                parentField = optParentField.get();
            } else {
                PreconditionUtil.verify(parentAttribute.getName().endsWith("Id"),
                        "nested identifier must have @JsonApiRelationId field being named with a 'Id' suffix or match in name with a @JsonApiRelationId annotated field on the resource, got %s for %s",
                        parentAttribute.getName(), beanInformation.getImplementationClass());

                parentField = findRelationshipFieldByName(relationshipName);
                PreconditionUtil.verify(parentField != null,
                        "naming of relationship to parent resource and relationship identifier within resource identifier must "
                                + "match, not found for %s of %s",
                        parentAttribute.getName(), implementationClass);

                ((ResourceFieldImpl) parentField).setIdField(parentAttribute.getName(), parentAttribute.getImplementationClass(), parentIdAccessor);
            }

            return true;
        }
        return false;
    }
990738
private boolean hasEntityBeanInterface(String[] interfaces) {
    for (int i = 0; i < interfaces.length; i++) {
      if (interfaces[i].equals(C_ENTITYBEAN)) {
        return true;
      }
    }
    return false;
  }
1103460
public final boolean isStatelessSessionBean(BeanId id) {
        boolean result = id.getHome().isStatelessSessionHome();
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "isStatelessSessionBean : " + result + ", " + id);
        return result;
    }
1027966
public static boolean notAllNullParameterCheck(Object parameter, String fields) {
        if (parameter != null) {
            try {
                Set<EntityColumn> columns = EntityHelper.getColumns(parameter.getClass());
                Set<String> fieldSet = new HashSet<String>(Arrays.asList(fields.split(",")));
                for (EntityColumn column : columns) {
                    if (fieldSet.contains(column.getProperty())) {
                        Object value = column.getEntityField().getValue(parameter);
                        if (value != null) {
                            return true;
                        }
                    }
                }
            } catch (Exception e) {
                throw new MapperException(SAFE_DELETE_ERROR, e);
            }
        }
        throw new MapperException(SAFE_DELETE_EXCEPTION);
    }
86187
public boolean hasParams() {
		return !cookieParams.isEmpty() || !urlParams.isEmpty() || !formParams.isEmpty() || !headerParams.isEmpty() || !multipartParams.isEmpty();
	}
102049
public static final boolean hasProperty(Object bean, String property)
    {
        try
        {
            return (boolean) doFor(
                bean, 
                property, 
                null,
                (Object a, int i)->{return true;},
                (List l, int i)->{return true;},
                (Object b, Class c, String p)->{getField(c, p);return true;}, 
                (Object b, Method m)->{return true;});
        }
        catch (BeanHelperException ex)
        {
            return false;
        }
    }
649319
public boolean hasSingleOptionalValue() {

        return ((getEntityType().getAttributeMinOccurrence(m_attributeName) == 0)
            && (m_entity.getAttribute(m_attributeName) != null)
            && (m_entity.getAttribute(m_attributeName).getValueCount() == 1));
    }
761264
protected boolean enlist(BeanO beanO)
                    throws TransactionRolledbackException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled(); // d532639.2

        if (isTraceOn && tc.isEntryEnabled()) // d144064
            Tr.entry(tc, "enlist"
                     , new Object[] { Boolean.valueOf(globalTransaction), this, beanO }
                            ); //123293

        ensureActive();

        if (ivBeanOsEnlistedInTx == false) // d532639.2
        {
            initialize_beanO_vectors(); // d111555
        }

        boolean wasEnlisted = false;//d132828 avoid multiple returns

        //synchronized (beanOs) {  //d173022.2

        BeanO oldBeanO = beanOs.put(beanO.beanId, beanO);

        //d115597 begins

        if (oldBeanO == null) {

            // d140003.22 -- If CMP 2.0 bean, add bean to CMP 2.0 list for later use
            // Except, don't add ReadOnly/Interval beans to CMP 2.0 list; they
            // never need to be included in pre-find flush.               LI3408
            BeanMetaData bmd = beanO.home.beanMetaData;
            if (bmd.cmpVersion == InternalConstants.CMP_VERSION_2_X &&
                bmd.ivCacheReloadType == BeanMetaData.CACHE_RELOAD_NONE)
            {
                ArrayList<BeanO> bundle = homesForPMManagedBeans.get(beanO.home);

                if (bundle == null) { // here, value of null indicates no bundle in map
                    bundle = new ArrayList<BeanO>();
                    homesForPMManagedBeans.put(beanO.home, bundle);
                }

                bundle.add(beanO);
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "Added this BeanO to CMP20 structure");
            }

            afterList.add(beanO);//d115597 if new BeanO add to afterList
            if (origLock == false) {
                beanOList.add(beanO);//d115597 have not started beforeCompletion

            } else {
                setupTempLists();//d132828
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "sec enlist new : " + beanO);

                currentBeanOs.put(beanO.beanId, beanO);//d115597 new bean added once beforeCompletion called
                tempList.add(beanO); //d115597 add to the tempList
            }

            wasEnlisted = true;//d132828 avoid multiple returns

        }//new beanO
        else {
            // d115597 this bean is already in the tran, need to determine if this is a reenlistment
            if (origLock == true) {
                // d115597 this path is that beforeCompletion has started
                setupTempLists(); //d132828

                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "enlist in beforeCompletion: putting in list");

                BeanO obO = currentBeanOs.put(beanO.beanId, beanO);

                if (obO == null) {
                    if (isTraceOn && tc.isDebugEnabled())
                        Tr.debug(tc, "Secondary enlist old : " + beanO);

                    // d115597 is this in the current list if not add?
                    tempList.add(beanO);
                }// d115597 not in current tran list

                // d115597 should return false
            }// d115597 not in original list of beanos (2nd or greater run through

        }// old beanO
         //d115597 end
         //}//synch end

        if (isTraceOn && tc.isEntryEnabled()) // d144064
            Tr.exit(tc, "enlist : " + wasEnlisted); // d144064

        return wasEnlisted;// d132828 avoid multiple returns
    }
647189
private boolean hasOperationOfType(SQLiteDatabaseSchema schema, MethodSpec.Builder methodBuilder, JQLType jqlType) {
		boolean hasOperation = false;
		for (SQLiteDaoDefinition daoDefinition : schema.getCollection()) {

			if (daoDefinition.getElement().getAnnotation(BindContentProviderPath.class) == null)
				continue;

			for (SQLiteModelMethod daoMethod : daoDefinition.getCollection()) {
				if (daoMethod.jql.operationType != jqlType) {
					continue;
				}
				if (!daoMethod.hasAnnotation(BindContentProviderEntry.class)) {
					continue;
				}

				hasOperation = true;
				// methodBuilder.addJavadoc("method $L.$L\n",
				// daoDefinition.getName(), daoMethod.getName());
			}
		}
		return hasOperation;
	}
1319595
public boolean check() {
        if (!method.getReturnType().equals(Void.TYPE)) {
            WebSocketRouter.getLogger().error("The method {} annotated with a web socket callback is not well-formed. " +
                            "These methods receive only parameter annotated with @Parameter and do not return anything",
                    method.getName()
            );
            return false;
        }

        List<ActionParameter> localArguments = buildArguments(method);
        if (localArguments == null) {
            return false;
        } else {
            this.arguments = localArguments;
            return true;
        }
    }
169154
public boolean hasDeclaredMethodParameterAnnotation(final String methodParameterAnnotationName) {
        for (final MethodInfo mi : getDeclaredMethodInfo()) {
            if (mi.hasParameterAnnotation(methodParameterAnnotationName)) {
                return true;
            }
        }
        return false;
    }
46279
public boolean hasAllMandatoryParameters() {
        if (this.f_Parameters.get(_INDEX_F_MessageType) == null
                || this.f_Parameters.get(_INDEX_F_MessageType).getCode() != this.getMessageType().getCode()) {
            return false;
        }

        return true;
    }
222270
public boolean hasParameter(String parameter) {
    if (info == null || info.parameters == null) {
      return false;
    }
    return info.parameters.containsKey(parameter);
  }