Returns {@code true}, if at least on of the sub-constraints still has to process a case i.e.
there is at least one sub-constraint with {@code hasNextCase() ==
true}.

@return true, if one of the sub-constrains still has cases
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;
	}
101717
public static boolean isConstraintSatisfied(Project project,
            Set<Class<ProjectFacet>> requiredFacets)
   {
      boolean constraintsSatisfied = true;
      Iterable<StackFacet> stackFacets = project.getFacets(StackFacet.class);
      OUTER: for (StackFacet stackFacet : stackFacets)
      {
         for (Class<ProjectFacet> type : requiredFacets)
         {
            if (!stackFacet.getStack().supports(type))
            {
               constraintsSatisfied = false;
               break OUTER;
            }
         }
      }
      return constraintsSatisfied;
   }
1355247
public boolean hasNext()
    {
        while (_list.hasMoreTokens() && (_current.length() == 0))
        {
            _current = _list.nextToken();
        }
        return (_current.length() > 0);
    }
1266579
public boolean isBound()
    {
        //
        // Constrained properties are implicitly bound.  Refer to section 7.4.3 of the JavaBeans
        // spec for the rationale.
        //
        PropertyInfo propInfo = getPropertyInfo();
        return propInfo != null && (propInfo.bound() || propInfo.constrained());
    }
444565
public boolean hasUnsupportedCriticalExtension() {
        if (info == null)
            return false;
        try {
            CertificateExtensions exts = (CertificateExtensions)info.get(
                                         CertificateExtensions.NAME);
            if (exts == null)
                return false;
            return exts.hasUnsupportedCriticalExtension();
        } catch (Exception e) {
            return false;
        }
    }
355594
@Override
	public int countCases() {
		int counter = 1;
		for (Constraint c : map.values()) {
			counter = Math.max(counter, c.countCases());
		}
		return counter;
	}
791119
private Boolean constraintsExists(String labelName, List<String> propertyNames) {
        Schema schema = db.schema();

        for (ConstraintDefinition constraintDefinition : Iterables.asList(schema.getConstraints(Label.label(labelName)))) {
            List<String> properties = Iterables.asList(constraintDefinition.getPropertyKeys());

            if (properties.equals(propertyNames)) {
                return true;
            }
        }

        return false;
    }
1349227
@Override
	public boolean hasNext() {
		if (isLoopExitCondition()) {
			return false;
		}
		for (;;) {
			if (workingDirectory.files.length == 0) {
				pop();
			}
			if (isLoopExitCondition()) {
				return false;
			}
			workingDirectory.currentFile = workingDirectory.files[workingDirectory.index++];
			if (!workingDirectory.currentFile.isDirectory()) {
				break;
			}
			push(workingDirectory.currentFile);
		}
		return true;
	}
587720
public boolean hasNextQuery() {
		for (int i=0; i<innerLearners.length; i++) {
			if (innerLearners[i].hasNextQuery()) return true;
		}
		return comboHasNextQuery();
	}
1325654
private boolean checkConstraint(Collection<String> constraints, Tile tile)
    {
        return tile != null
               && constraints.contains(mapGroup.getGroup(tile))
               && !tile.getFeature(TileCollision.class).getCollisionFormulas().isEmpty();
    }
1010409
public boolean hasNext() {
		if(done) return false;
		if(cachedNext != null) {
			return true;
		}
		while(inner.hasNext()) {
			String tmp = inner.next();
			if(tmp.startsWith(prefix)) {
				cachedNext = tmp;
				return true;
			} else if(tmp.compareTo(prefix) > 0) {
				done = true;
				return false;
			}
		}
		return false;
	}
819752
public boolean contains(IntBitRelation sub) {
        int i;

        if (line.length != sub.line.length) {
            return false;
        }

        for (i = 0; i < line.length; i++) {
            if (line[i] == null) {
                if (sub.line[i] != null) {
                    return false;
                }
            } else {
                if ((sub.line[i] != null) &&
                    !line[i].containsAll(sub.line[i])) {
                    return false;
                }
            }
        }
        return true;
    }
1078558
public static boolean isLoadCase(final ProcessCase[] cases) {

        if(cases == null || cases.length == 0) {
            return true;
        }

        for(ProcessCase pc : cases) {
            if(pc == ProcessCase.Load) {
                return true;
            }
        }

        return false;

    }
1114185
public boolean hasNext() {

        if (items != null) {
            if (items.hasNext()) {
                return (true);
            } else {
                items = null;
            }
        }
        Object next = findNextValidChild();
        while (next != null) {
            initializeItems(next);
            if (items != null) {
                return true;
            } else {
                next = findNextValidChild();
            }
        }
        return false;

    }
1127825
public boolean hasNext() {
        if (currentIndex == endIndex) {
            return false;
        }
              
        // Otherwise, see if nextElement is null. If so, try to load the next
        // element to make sure it exists.
        if (nextElement == null) {
            nextElement = getNextElement();
            if (nextElement == null) {
                return false;
            }
        }
        return true;
    }
994898
public boolean hasSingleActions() {

        Iterator<CmsListColumnDefinition> itCols = m_columns.elementList().iterator();
        while (itCols.hasNext()) {
            CmsListColumnDefinition col = itCols.next();
            if (!col.getDefaultActions().isEmpty() || !col.getDirectActions().isEmpty()) {
                return true;
            }
        }
        return false;
    }
580682
@Override
	public boolean hasNext() {
		if (!isForward) {
			currentRec = currentRec - pointerSize;
			isForward = true;
		}
		return currentRec > 0 || blk.number() > 0;
	}