Does the specified BDA, or any of BDAs accessible by it, have any beans or it is an extension which could add beans

@param bda the BDA
@return true if the specified BDA, or any of BDAs accessible by it, have any beans
10936
private boolean isCDIEnabled(WebSphereBeanDeploymentArchive bda) {
        Boolean hasBeans = cdiStatusMap.get(bda.getId());
        if (hasBeans == null) {
            //it's enabled if it has beans or it is an extension which could add beans
            hasBeans = bda.hasBeans() || bda.isExtension();
            //setting this now should prevent loops when checking children in the next step
            cdiStatusMap.put(bda.getId(), hasBeans);

            //it's also enabled if any of it's children are enabled (but not including runtime extensions)
            hasBeans = hasBeans || isCDIEnabled(bda.getWebSphereBeanDeploymentArchives());
            //remember the result
            cdiStatusMap.put(bda.getId(), hasBeans);
        }

        return hasBeans;
    }
953322
public final boolean hasProperty(final String property) {
    final String val = properties.get(property);
    if (val == null)
      return false;
    if (val.isEmpty())
      return false;
    return true;
  }
855247
public void add(BeanId beanId)
    {
        BeanId[] buckets = this.ivBuckets;
        buckets[(beanId.hashValue & 0x7FFFFFFF) % buckets.length] = beanId;
    }
471109
public static boolean haveCommonElement(int[] arra, int[] arrb,
            int bcount) {

        for (int i = 0; i < arra.length; i++) {
            int c = arra[i];

            for (int j = 0; j < bcount; j++) {
                if (c == arrb[j]) {
                    return true;
                }
            }
        }

        return false;
    }
192252
public boolean isForbidden() {
        if (authorities.size() == 0) {
            return false; // If no restrictions, return false
        }

        boolean result = true;

        for (Authority priv : authorities) {
            result = !SecurityUtil.isGranted(priv.name);

            if (requiresAll == result) {
                break;
            }
        }

        return result;
    }
570845
private boolean isQueryBeanPackage(String domainPackage) {
    for (int i = 0; i < packages.length; i++) {
      if (domainPackage.startsWith(packages[i])) {
        return true;
      }
    }
    return false;
  }
332507
@Override
	public boolean hasNextCase() {
		// this method only returns true if dependent values are grouped
		if (!dependent) {
			return false;
		}
		for (Constraint c : constraints) {
			if (c.hasNextCase()) {
				return true;
			}
		}
		return false;
	}
500763
protected boolean isBaseEmpty() {
		if (myUndeclaredExtensions != null) {
			for (ExtensionDt next : myUndeclaredExtensions) {
				if (next == null) {
					continue;
				}
				if (!next.isEmpty()) {
					return false;
				}
			}
		}
		if (myUndeclaredModifierExtensions != null) {
			for (ExtensionDt next : myUndeclaredModifierExtensions) {
				if (next == null) {
					continue;
				}
				if (!next.isEmpty()) {
					return false;
				}
			}
		}
		return true;
	}
611771
public boolean hasMonomer(String polymerType, String alternateId) {
    return ((monomerDB.get(polymerType) != null) && getMonomer(polymerType, alternateId) != null);
  }
677130
public static boolean hasDSLSentences(final GuidedDecisionTable52 model) {
        for (CompositeColumn<? extends BaseColumn> column : model.getConditions()) {
            if (column instanceof BRLConditionColumn) {
                final BRLConditionColumn brlColumn = (BRLConditionColumn) column;
                for (IPattern pattern : brlColumn.getDefinition()) {
                    if (pattern instanceof DSLSentence) {
                        return true;
                    }
                }
            }
        }
        for (ActionCol52 column : model.getActionCols()) {
            if (column instanceof BRLActionColumn) {
                final BRLActionColumn brlColumn = (BRLActionColumn) column;
                for (IAction action : brlColumn.getDefinition()) {
                    if (action instanceof DSLSentence) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
489225
public boolean has() {

		boolean exists = false;
		try {
			exists = has(EXTENSION_NAME, tableName, null)
					&& tileScalingDao.isTableExists()
					&& tileScalingDao.idExists(tableName);
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to check for tile scaling for GeoPackage: "
							+ geoPackage.getName() + ", Tile Table: "
							+ tableName, e);
		}

		return exists;
	}
136142
public boolean has() {

		boolean exists = false;
		try {
			exists = has(EXTENSION_NAME, null, null)
					&& contentsIdDao.isTableExists();
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to check for contents id for GeoPackage: "
							+ geoPackage.getName(), e);
		}

		return exists;
	}
524361
private Set<WebSphereBeanDeploymentArchive> createExtensionBDAs(WebSphereCDIDeployment applicationContext) throws CDIException {

        Set<WebSphereBeanDeploymentArchive> extensionBdas = new HashSet<WebSphereBeanDeploymentArchive>();

        Set<ExtensionArchive> extensions = getExtensionArchives();

        if (extensions != null) {
            for (ExtensionArchive extArchive : extensions) {

                WebSphereBeanDeploymentArchive moduleCDIContext = BDAFactory.createBDA(applicationContext,
                                                                                       extArchive,
                                                                                       cdiRuntime);
                extensionBdas.add(moduleCDIContext);
            }
        }

        return extensionBdas;
    }
410017
public void addDiscoveredBda(ArchiveType moduleType, WebSphereBeanDeploymentArchive bda) throws CDIException {
        webSphereCDIDeployment.addBeanDeploymentArchive(bda);
        Set<WebSphereBeanDeploymentArchive> bdaSet = bdasByType.get(moduleType);
        if (bdaSet != null) {
            bdaSet.add(bda);
        } else {
            if (tc.isDebugEnabled()) {
                Tr.debug(tc, "Ignore this type: {0}, as CDI does not need to add this in the addDiscoveredBda ", moduleType);
            }
        }

        String path = bda.getArchive().getPath();
        if (moduleType == ArchiveType.SHARED_LIB || moduleType == ArchiveType.EAR_LIB) {
            libraryPaths.add(path);
        } else if (moduleType == ArchiveType.RAR_MODULE || moduleType == ArchiveType.EJB_MODULE) {
            modulePaths.add(path);
        }
    }
587720
public boolean hasNextQuery() {
		for (int i=0; i<innerLearners.length; i++) {
			if (innerLearners[i].hasNextQuery()) return true;
		}
		return comboHasNextQuery();
	}
1020277
public boolean processSecondRound(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
		for (SQLiteDatabaseSchema schema : schemas) {

			// Analyze beans BEFORE daos, because beans are needed for DAO
			// definition
			for (String daoName : schema.getDaoNameSet()) {
				// check dao into bean definition
				if (globalDaoGenerated.contains(daoName)) {
					createSQLEntityFromDao(schema, schema.getElement(), daoName);
					createSQLDaoDefinition(schema, globalBeanElements, globalDaoElements, daoName);
				}
			} // end foreach bean

		} // end foreach dataSource

		return true;
	}
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;
	}