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

@param index
The index to check.
@return true or false.
182358
public boolean isVertex(GeometryIndex index) {
		if (index.hasChild()) {
			return isVertex(index.getChild());
		}
		return index.getType() == GeometryIndexType.TYPE_VERTEX;
	}
942672
public GeometryIndex getParent(GeometryIndex index) {
		GeometryIndex parent = new GeometryIndex(index);
		GeometryIndex deepestParent = null;
		GeometryIndex p = parent;
		while (p.hasChild()) {
			deepestParent = p;
			p = p.getChild();
		}
		if (deepestParent != null) {
			deepestParent.setChild(null);
		}
		return parent;
	}
890379
private boolean containsKey(final int key, final int index) {
        return (key != 0 || states[index] == FULL) && keys[index] == key;
    }
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;
    }
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 + ")");
        }
    }
274231
public boolean contains(long index) {
    assertSegmentOpen();

    if (!validIndex(index))
      return false;

    // Check the memory index first for performance reasons.
    long offset = relativeOffset(index);
    return offsetIndex.contains(offset);
  }
510825
private boolean valueCached(int index) {
        boolean result = false;

        if (generatedCacheMap.containsKey(index) == true || resultSetCacheMap.containsKey(index) == true) {
            result = true;
        }

        return result;
    }
1305216
public boolean exists(String index) {
        boolean exists = false;

        if (indexNames.isEmpty() == false) {
            for (i = 0; i < indexNames.size(); i++) {
                if (index.equals((String) indexNames.elementAt(i))) {
                    exists = true;
                    break;
                }
            }
        }

        return exists;
    }
1073898
private void checkSmallBin(int index) {
    long h = smallBins[index];

    boolean empty = (smallMap & (1 << index)) == 0;
    if (h == -1 && !empty) {
      throw new AssertionError("Small bin chain " + index + " is marked as occupied but has an invalid head pointer");
    }
    if (!empty) {
      long p = h;
      do {
        long size = chunkSize(p);
        /* each chunk claims to be free */
        checkFreeChunk(p);
        /* chunk belongs in bin */
        if (smallBinIndex(size) != index)
          throw new AssertionError("Chunk " + p + " is the wrong size to be in bin " + index);
        if (backward(p) != p && chunkSize(backward(p)) != chunkSize(p))
          throw new AssertionError("Chunk " + p + " is the linked to a chunk of the wrong size");
        /* chunk is followed by an inuse chunk */
        checkInUseChunk(nextChunk(p));

        p = backward(p);
      } while (p != h);
    }
  }
76291
public int locateIndex(int index) {

        int min = 0;
        int max = this.indexValues.length - 1;

        if (max == -1) {
            return -1;
        }

        // Binary search
        while ((this.indexValues[min] <= index) && (this.indexValues[max] >= index)) {
            int current = (max + min) / 2;
            if (this.indexValues[current] > index) {
                max = current - 1;
            } else if (this.indexValues[current] < index) {
                min = current + 1;
            } else {
                return current;
            }
        }
        if (this.indexValues[max] < index) {
            return max;
        } else {
            return min - 1;
        }
    }
1005143
public int getAttributeSize(int index) {
        final VertexAttribute attribute = getAttribute(index);
        if (attribute == null) {
            return -1;
        }
        return attribute.getSize();
    }
978289
@Override
	public Point3D getXYZ(int index) {
		if (index < 0 || index >= getPointCount())
			throw new IndexOutOfBoundsException();

		_verifyAllStreams();
		AttributeStreamOfDbl v = (AttributeStreamOfDbl) m_vertexAttributes[0];
		Point3D pt = new Point3D();
		pt.x = v.read(index * 2);
		pt.y = v.read(index * 2 + 1);

		// TODO check excluded if statement componenet
		if (hasAttribute(Semantics.Z))// && (m_vertexAttributes[1] != null))
			pt.z = m_vertexAttributes[1].readAsDbl(index);
		else
			pt.z = VertexDescription.getDefaultValue(Semantics.Z);

		return pt;
	}
1001663
public boolean removeB(int index)
    {
        boundsCheck(index);
        boolean ret = array[index];
        for(int i = index; i < end-1; i++)
            array[i] = array[i+1];
        decreaseSize(1);
        return ret;
    }
279908
public boolean scrollListToBottom(int index) {
		if(config.commandLogging){
			Log.d(config.commandLoggingTag, "scrollListToBottom("+index+")");
		}
		
		return scroller.scrollList(waiter.waitForAndGetView(index, ListView.class), Scroller.DOWN, true);
	}
289315
public boolean isChildOf(GeometryIndex parentIndex, GeometryIndex childIndex) {
		if (parentIndex.getValue() != childIndex.getValue()) {
			return false;
		}
		if (parentIndex.hasChild() && childIndex.hasChild()) {
			return isChildOf(parentIndex.getChild(), childIndex.getChild());
		} else if (!parentIndex.hasChild() && childIndex.hasChild()) {
			return true;
		}
		return false;
	}
590266
public void set(int index) {
		Preconditions.checkArgument(index < bitLength && index >= 0);

		int byteIndex = (index & BYTE_POSITION_MASK) >>> 3;
		byte current = memorySegment.get(offset + byteIndex);
		current |= (1 << (index & BYTE_INDEX_MASK));
		memorySegment.put(offset + byteIndex, current);
	}
743143
protected boolean isArgumentSensitive(int index) {
        if (methodInfo != null) {
            return methodInfo.isArgSensitive(index);
        }
        Set<Type> parameterAnnotations = observedParameterAnnotations.get(index);
        if (parameterAnnotations != null) {
            return parameterAnnotations.contains(SENSITIVE_TYPE);
        }
        return false;
    }