Used to determine if multiple cost rates apply to this assignment.

@return true if multiple cost rates apply to this assignment
496416
private boolean hasMultipleCostRates()
   {
      boolean result = false;
      CostRateTable table = getCostRateTable();
      if (table != null)
      {
         //
         // We assume here that if there is just one entry in the cost rate
         // table, this is an open ended rate which covers any work, it won't
         // have specific dates attached to it.
         //
         if (table.size() > 1)
         {
            //
            // If we have multiple rates in the table, see if the same rate
            // is in force at the start and the end of the aaaignment.
            //
            CostRateTableEntry startEntry = table.getEntryByDate(getStart());
            CostRateTableEntry finishEntry = table.getEntryByDate(getFinish());
            result = (startEntry != finishEntry);
         }
      }
      return result;
   }
552623
public boolean isAllSelected()
    {
        boolean bAllSelected = true;
        for (int iFieldSeq = DBConstants.MAIN_FIELD; iFieldSeq <= this.getFieldCount() + DBConstants.MAIN_FIELD - 1; iFieldSeq++)
        {
            if(this.getField(iFieldSeq).isSelected() == false)
                bAllSelected = false;
        }
        return bAllSelected;
    }
168906
public boolean hasState() {
		for (OperatorSubtaskState operatorSubtaskState : subtaskStatesByOperatorID.values()) {
			if (operatorSubtaskState != null && operatorSubtaskState.hasState()) {
				return true;
			}
		}
		return false;
	}
287456
private static boolean multiPointRelateMultiPoint_(MultiPoint multipoint_a,
			MultiPoint multipoint_b, double tolerance, int relation,
			ProgressTracker progress_tracker) {
		switch (relation) {
		case Relation.disjoint:
			return multiPointDisjointMultiPoint_(multipoint_a, multipoint_b,
					tolerance, progress_tracker);

		case Relation.within:
			return multiPointContainsMultiPoint_(multipoint_b, multipoint_a,
					tolerance, progress_tracker);

		case Relation.contains:
			return multiPointContainsMultiPoint_(multipoint_a, multipoint_b,
					tolerance, progress_tracker);

		case Relation.equals:
			return multiPointEqualsMultiPoint_(multipoint_a, multipoint_b,
					tolerance, progress_tracker);

		case Relation.overlaps:
			return multiPointOverlapsMultiPoint_(multipoint_a, multipoint_b,
					tolerance, progress_tracker);

		default:
			break; // warning fix
		}

		return false;
	}
309056
public boolean isInitialized() {
    for (int i = 0; i < fields.getNumArrayEntries(); i++) {
      if (!isInitialized(fields.getArrayEntryAt(i))) {
        return false;
      }
    }
    for (final Map.Entry<FieldDescriptorType, Object> entry :
             fields.getOverflowEntries()) {
      if (!isInitialized(entry)) {
        return false;
      }
    }
    return true;
  }
577719
public boolean offer(T t) {
        boolean retval=super.offer(t);
        if(retval) count.incrementAndGet();
        return retval;
    }
979955
public boolean multipleConsumers() {
        // TODO: When HWKAPM-698 implemented, it may no longer be necessary to capture this info
        Set<Property> props=getProperties(Producer.PROPERTY_PUBLISH);
        return !props.isEmpty()
                && props.iterator().next().getValue().equalsIgnoreCase(Boolean.TRUE.toString());
    }
973446
public boolean hasCheckMultiActions() {

        Iterator<CmsListMultiAction> it = m_multiActions.elementList().iterator();
        while (it.hasNext()) {
            CmsListMultiAction action = it.next();
            if (!(action instanceof CmsListRadioMultiAction)) {
                return true;
            }
        }
        return false;
    }
795757
private boolean isAggregate(String thriftColumnName)
    {
        if (thriftColumnName.startsWith(SYS_COUNT) || thriftColumnName.startsWith(SYS_MIN)
                || thriftColumnName.startsWith(SYS_MAX) || thriftColumnName.startsWith(SYS_AVG)
                || thriftColumnName.startsWith(SYS_SUM))
        {
            return true;
        }
        else if (thriftColumnName.startsWith(COUNT) || thriftColumnName.startsWith(MIN)
                || thriftColumnName.startsWith(MAX) || thriftColumnName.startsWith(AVG)
                || thriftColumnName.startsWith(SUM))
        {
            return true;
        }
        return false;
    }
977236
public boolean isSet() {
        if (isUsageMode()) {
            return true;
        }
        if (getJobFile() != null) {
            return true;
        }
        if (getListType() != null) {
            return true;
        }
        return false;
    }
1034566
public static boolean isNearMultipleBorders(@Nonnull final Point point, @Nonnull final Territory territory) {
        checkDefined("point", point);
        if (territory != Territory.AAA) {
            final int territoryNumber = territory.getNumber();
            if (territory.getParentTerritory() != null) {
                // There is a parent! check its borders as well...
                if (isNearMultipleBorders(point, territory.getParentTerritory())) {
                    return true;
                }
            }
            int nrFound = 0;
            final int fromTerritoryRecord = DATA_MODEL.getDataFirstRecord(territoryNumber);
            final int uptoTerritoryRecord = DATA_MODEL.getDataLastRecord(territoryNumber);
            for (int territoryRecord = uptoTerritoryRecord; territoryRecord >= fromTerritoryRecord; territoryRecord--) {
                if (!Data.isRestricted(territoryRecord)) {
                    final Boundary boundary = Boundary.createBoundaryForTerritoryRecord(territoryRecord);
                    final int xdiv8 = Common.xDivider(boundary.getLatMicroDegMin(), boundary.getLatMicroDegMax()) / 4;
                    if (boundary.extendBoundary(60, xdiv8).containsPoint(point)) {
                        if (!boundary.extendBoundary(-60, -xdiv8).containsPoint(point)) {
                            nrFound++;
                            if (nrFound > 1) {
                                return true;
                            }
                        }
                    }
                }
            }
        }
        return false;
    }
1211997
public boolean hasMultipleAccess(String columnName){
		Timer timer = cat.startTimer();
		try {
	    	List<String> fields = columnFields.get(columnName);
	    	return (fields != null && fields.size() > 1);
		}finally{
			timer.stop();
		}
    }
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;
    }
1152990
public boolean hasBadValues() {
        for(int i=0; i<top; i++) {
            double v = vals[i];
            boolean bad = Double.isNaN(v) || Double.isInfinite(v);
            if(bad) return true;
        }
        return false;
    }
756713
private boolean checkForActiveConnections(int value) {
        /*
         * Check for active connections in the SharedPool
         */
        boolean activeConnections = false;

        /*
         * We have active connections or active pool requests if active requests
         * > 0 or the pool state is not = 1. In either case, we will consider the
         * pool active if statement is true.
         */
        if (value == 0) {
            mcToMCWMapWrite.lock();
            try {
                Collection<MCWrapper> mcWrappers = mcToMCWMap.values();
                Iterator<MCWrapper> mcWrapperIt = mcWrappers.iterator();
                while (mcWrapperIt.hasNext()) {
                    MCWrapper mcw = mcWrapperIt.next();
                    /*
                     * We have atleast one active connection.
                     */
                    /*
                     * If the value is zero, both tests are used.
                     */
                    if (activeRequest.get() > 0) {
                        activeConnections = true;
                        break;
                    } else {
                        int poolState = mcw.getPoolState();
                        if ((poolState != 1) && (poolState != 9)) {
                            activeConnections = true;
                            break;
                        }
                    }
                }
            } finally {
                mcToMCWMapWrite.unlock();
            }
        } else {
            /*
             * Only activeRequest is used.
             */
            if (activeRequest.get() > 0) {
                activeConnections = true;
            }
        }

        return activeConnections;
    }
33051
private boolean hasSameIndices(Collection<?> c) {
		return c != null 
				&& (c instanceof PairSet) 
				&& (allTransactions == ((PairSet) c).allTransactions)
				&& (allItems == ((PairSet) c).allItems);
	}
1010667
protected boolean checkMultipart(Invocation inv) throws MultipartException {
        if (inv.getRequest().getMethod() == null) {
            throw new NullPointerException("request.method");
        }
        if (this.multipartResolver.isMultipart(inv.getRequest())) {
            if (inv.getRequest() instanceof MultipartHttpServletRequest) {
                logger.debug("Request is already a MultipartHttpServletRequest");
                return true;
            } else {
                if (!inv.getMethod().isAnnotationPresent(SuppressMultipartResolver.class)) {
                    inv.setRequest(this.multipartResolver.resolveMultipart(inv.getRequest()));
                    return true;
                }
            }
        }
        return false;
    }