Does the given index point to an edge or not? We look at the deepest level to check this.

@param index
The index to check.
@return true or false.
199399
public boolean isEdge(GeometryIndex index) {
		if (index.hasChild()) {
			return isEdge(index.getChild());
		}
		return index.getType() == GeometryIndexType.TYPE_EDGE;
	}
292556
@Pure
	public Direction1D getSegmentDirectionAt(int index) {
		final RoadSegment sgmt = get(index);
		assert sgmt != null;
		final RoadConnection conn = getStartingPointFor(index);
		assert conn != null;
		if (conn.equals(sgmt.getBeginPoint())) {
			return Direction1D.SEGMENT_DIRECTION;
		}
		assert conn.equals(sgmt.getEndPoint());
		return Direction1D.REVERTED_DIRECTION;
	}
1349820
private static void checkRange(int fromIndex, int toIndex) {
		if (fromIndex < 0)
			throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);
		if (toIndex < 0)
			throw new IndexOutOfBoundsException("toIndex < 0: " + toIndex);
		if (fromIndex > toIndex)
			throw new IndexOutOfBoundsException("fromIndex: " + fromIndex +
					" > toIndex: " + toIndex);
	}
719300
public boolean isCheckBoxChecked(int index)
	{
		if(config.commandLogging){
			Log.d(config.commandLoggingTag, "isCheckBoxChecked("+index+")");
		}
		
		return checker.isButtonChecked(CheckBox.class, index);
	}
849271
public boolean isCompactable(long index) {
    Map.Entry<Long, JournalSegment<E>> segmentEntry = segments.floorEntry(index);
    return segmentEntry != null && segments.headMap(segmentEntry.getValue().index()).size() > 0;
  }
976379
public boolean isTouchedByRange(int globalStartIndex, int globalEndIndex) {
        return ((startIndex >= globalStartIndex) && (startIndex <= globalEndIndex))
                || ((endIndex >= globalStartIndex) && (endIndex <= globalEndIndex))
                || ((startIndex <= globalStartIndex) && (endIndex >= globalEndIndex));

    }
1032213
@Override
    public boolean isDeclared(int index)
    {
        if (index < mAttrCount) {
            if (index >= 0) {
                // !!! TODO: implement properly
                return true;
            }
        } else {
            index -= mAttrCount;
            if (index < mNsCount) {
                /* DTD and namespaces don't really play nicely together;
                 * and in general xmlns: pseudo-attributes are not declared...
                 * so not quite sure what to return here. For now, let's
                 * return true, to indicate they ought to be valid
                 */
                return true;
            }
        }
        throwNoSuchAttribute(index);
        return false; // never gets here
    }
1344162
public boolean nextIndex(long index) {
    if (operationIndex + 1 == index) {
      currentOperation = OperationType.COMMAND;
      operationIndex++;
      return true;
    }
    return false;
  }
1086833
private boolean canonize(int index) {
		final int count = getPointCount();

		int ix = index;
		if (ix < 0) {
			ix = count + ix;
		}
		if (ix < 0) {
			throw new IndexOutOfBoundsException(ix + "<0"); //$NON-NLS-1$
		}
		if (ix >= count) {
			throw new IndexOutOfBoundsException(ix + ">=" + count); //$NON-NLS-1$
		}

		final int partIndex = groupIndexForPoint(ix);

		final int firstPts = firstInGroup(partIndex);
		final int endPts = lastInGroup(partIndex);

		final int myIndex = ix * 2;
		int firstToRemove = myIndex;
		int lastToRemove = myIndex;
		boolean removeOne = false;

		final double xbase = this.pointCoordinates[ix * 2];
		final double ybase = this.pointCoordinates[ix * 2 + 1];

		final PointFusionValidator validator = getPointFusionValidator();

		// Search for the first point to remove
		for (int idx = myIndex - 2; idx >= firstPts; idx -= 2) {
			final double x = this.pointCoordinates[idx];
			final double y = this.pointCoordinates[idx + 1];
			if (validator.isSame(xbase, ybase, x, y)) {
				firstToRemove = idx;
				removeOne = true;
			} else {
				// Stop search
				break;
			}
		}

		// Search for the last point to remove
		for (int idx = myIndex + 2; idx <= endPts; idx += 2) {
			final double x = this.pointCoordinates[idx];
			final double y = this.pointCoordinates[idx + 1];
			if (validator.isSame(xbase, ybase, x, y)) {
				lastToRemove = idx;
				removeOne = true;
			} else {
				// Stop search
				break;
			}
		}

		if (removeOne) {
			// A set of points are detected as too near.
			// They should be removed and replaced by the reference point

			final int removalCount = (lastToRemove / 2 - firstToRemove / 2) * 2;

			// Deleting the point
			final double[] newPtsArray = new double[this.pointCoordinates.length - removalCount];
			assert newPtsArray.length >= 2;

			System.arraycopy(this.pointCoordinates, 0, newPtsArray, 0, firstToRemove);
			System.arraycopy(this.pointCoordinates, lastToRemove + 2, newPtsArray,
					firstToRemove + 2, this.pointCoordinates.length - lastToRemove - 2);
			newPtsArray[firstToRemove] = xbase;
			newPtsArray[firstToRemove + 1] = ybase;

			this.pointCoordinates = newPtsArray;

			if (this.partIndexes != null) {
				// Shift the group's indexes
				for (int i = partIndex; i < this.partIndexes.length; ++i) {
					this.partIndexes[i] -= removalCount;
				}
			}

			return true;
		}

		return false;
	}
704730
public Boolean hasIndex() {

        Boolean hasIndex = false;
        if (this.indexedFastaSequenceFile != null) {
            hasIndex = this.indexedFastaSequenceFile.isIndexed();
        }
        return hasIndex;
    }
240200
public boolean remove(int index) {

        Widget w = getWidget(index);
        if (w != null) {
            return remove(getWidget(index));
        }
        return false;
    }
846720
public function isFocused( $index = NULL ){
		if( !count( $this->focusedIndices ) )
			return FALSE;
		if( $index && !array_key_exists( $index, $this->focusedIndices ) )
			return FALSE;
		return TRUE;
	}
259379
public boolean isNull(int index) {
		Object value = opt(index);
		return value == null || value == JSONObject.NULL;
	}
822698
protected void checkBounds(int index) throws IOException {
        assertInput();
        if (index < getMinIndex()) {
            throw new IndexOutOfBoundsException("index < minIndex");
        }

        int numImages = getNumImages(false);
        if (numImages != -1 && index >= numImages) {
            throw new IndexOutOfBoundsException("index >= numImages (" + index + " >= " + numImages + ")");
        }
    }
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;
    }
79677
public boolean get(int index) throws ArrayIndexOutOfBoundsException {
        if (index < 0 || index >= length) {
            throw new ArrayIndexOutOfBoundsException(Integer.toString(index));
        }

        return (repn[subscript(index)] & position(index)) != 0;
    }
1048385
public JobEdge getBackwardConnection(final int index) {

		if (index < this.backwardEdges.size()) {
			return this.backwardEdges.get(index);
		}

		return null;
	}