Set the z index

@param zIndex z index
@since 2.0.1
431799
public void setZIndex(float zIndex) {

        switch (shapeType) {

            case MARKER_OPTIONS:
                ((MarkerOptions) shape).zIndex(zIndex);
                break;
            case POLYLINE_OPTIONS:
                ((PolylineOptions) shape).zIndex(zIndex);
                break;
            case POLYGON_OPTIONS:
                ((PolygonOptions) shape).zIndex(zIndex);
                break;
            case MULTI_POLYLINE_OPTIONS:
                ((MultiPolylineOptions) shape).zIndex(zIndex);
                break;
            case MULTI_POLYGON_OPTIONS:
                ((MultiPolygonOptions) shape).zIndex(zIndex);
                break;
            case MARKER:
                ((Marker) shape).setZIndex(zIndex);
                break;
            case POLYGON:
                ((Polygon) shape).setZIndex(zIndex);
                break;
            case POLYLINE:
                ((Polyline) shape).setZIndex(zIndex);
                break;
            case MULTI_MARKER:
                ((MultiMarker) shape).setZIndex(zIndex);
                break;
            case MULTI_POLYLINE:
                ((MultiPolyline) shape).setZIndex(zIndex);
                break;
            case MULTI_POLYGON:
                ((MultiPolygon) shape).setZIndex(zIndex);
                break;
            case POLYLINE_MARKERS:
                ((PolylineMarkers) shape).setZIndex(zIndex);
                break;
            case POLYGON_MARKERS:
                ((PolygonMarkers) shape).setZIndex(zIndex);
                break;
            case MULTI_POLYLINE_MARKERS:
                ((MultiPolylineMarkers) shape).setZIndex(zIndex);
                break;
            case MULTI_POLYGON_MARKERS:
                ((MultiPolygonMarkers) shape).setZIndex(zIndex);
                break;
            case COLLECTION:
                @SuppressWarnings("unchecked")
                List<GoogleMapShape> shapeList = (List<GoogleMapShape>) shape;
                for (GoogleMapShape shapeListItem : shapeList) {
                    shapeListItem.setZIndex(zIndex);
                }
                break;
            default:
        }

    }
908591
void setSize(int x, int y, int z)
    {
        this.sizeX = x;
        this.sizeY = y;
        this.sizeZ = z;
    }
753391
function() {
        var index = this.layer.getZIndex() - 1;
        if (index >= this.map.Z_INDEX_BASE['Feature']) {
            this.layer.setZIndex(index);
        } else {
            this.map.setLayerZIndex(this.layer,
                this.map.getLayerIndex(this.layer));
        }
    }
64814
void setBlock(final int index, final Block b) {
    blockList[index2BlockId(index)] = b.getBlockId();
    blockList[index2BlockLen(index)] = b.getNumBytes();
    blockList[index2BlockGenStamp(index)] = b.getGenerationStamp();
  }
1221741
public void setPosition (float x, float y, float z)
    {
        if (_px != x || _py != y || _pz != z) {
            AL10.alSource3f(_id, AL10.AL_POSITION, _px = x, _py = y, _pz = z);
        }
    }
474709
@Override
	public void set(double x, double y, double z, double radius1) {
		this.cxProperty.set(x);
		this.cyProperty.set(y);
		this.czProperty.set(z);
		this.radiusProperty.set(Math.abs(radius1));
	}
1103954
public void setPosition(int newIndex) {

    //check NULL-Bitmap that indicate if field is null
    if ((buf[1 + (newIndex + 2) / 8] & (1 << ((newIndex + 2) % 8))) != 0) {
      this.lastValueNull = BIT_LAST_FIELD_NULL;
      return;
    }

    //if not must parse data until reading the desired field
    if (index != newIndex) {
      int internalPos = this.pos;
      if (index == -1 || index > newIndex) {
        //if there wasn't previous non-null read field, or if last field was after searched index,
        // position is set on first field position.
        index = 0;
        internalPos = 1 + (columnInformationLength + 9) / 8; // 0x00 header + NULL-Bitmap length
      } else {
        //start at previous non-null field position if was before searched index
        index++;
        internalPos += length;
      }

      for (; index <= newIndex; index++) {
        if ((buf[1 + (index + 2) / 8] & (1 << ((index + 2) % 8))) == 0) {
          if (index != newIndex) {
            //skip bytes
            switch (columnInformation[index].getColumnType()) {
              case BIGINT:
              case DOUBLE:
                internalPos += 8;
                break;

              case INTEGER:
              case MEDIUMINT:
              case FLOAT:
                internalPos += 4;
                break;

              case SMALLINT:
              case YEAR:
                internalPos += 2;
                break;

              case TINYINT:
                internalPos += 1;
                break;

              default:
                int type = this.buf[internalPos++] & 0xff;
                switch (type) {

                  case 251:
                    break;

                  case 252:
                    internalPos +=
                        2 + (0xffff & (((buf[internalPos] & 0xff) + ((buf[internalPos + 1] & 0xff)
                            << 8))));
                    break;

                  case 253:
                    internalPos += 3 + (0xffffff & ((buf[internalPos] & 0xff)
                        + ((buf[internalPos + 1] & 0xff) << 8)
                        + ((buf[internalPos + 2] & 0xff) << 16)));
                    break;

                  case 254:
                    internalPos += 8 + ((buf[internalPos] & 0xff)
                        + ((long) (buf[internalPos + 1] & 0xff) << 8)
                        + ((long) (buf[internalPos + 2] & 0xff) << 16)
                        + ((long) (buf[internalPos + 3] & 0xff) << 24)
                        + ((long) (buf[internalPos + 4] & 0xff) << 32)
                        + ((long) (buf[internalPos + 5] & 0xff) << 40)
                        + ((long) (buf[internalPos + 6] & 0xff) << 48)
                        + ((long) (buf[internalPos + 7] & 0xff) << 56));
                    break;

                  default:
                    internalPos += type;
                    break;
                }
                break;
            }
          } else {
            //read asked field position and length
            switch (columnInformation[index].getColumnType()) {
              case BIGINT:
              case DOUBLE:
                this.pos = internalPos;
                length = 8;
                this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                return;

              case INTEGER:
              case MEDIUMINT:
              case FLOAT:
                this.pos = internalPos;
                length = 4;
                this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                return;

              case SMALLINT:
              case YEAR:
                this.pos = internalPos;
                length = 2;
                this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                return;

              case TINYINT:
                this.pos = internalPos;
                length = 1;
                this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                return;

              default:
                //field with variable length
                int type = this.buf[internalPos++] & 0xff;
                switch (type) {
                  case 251:
                    //null length field
                    //must never occur
                    //null value are set in NULL-Bitmap, not send with a null length indicator.
                    throw new IllegalStateException(
                        "null data is encoded in binary protocol but NULL-Bitmap is not set");

                  case 252:
                    //length is encoded on 3 bytes (0xfc header + 2 bytes indicating length)
                    length = 0xffff & ((buf[internalPos++] & 0xff)
                        + ((buf[internalPos++] & 0xff) << 8));
                    this.pos = internalPos;
                    this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                    return;

                  case 253:
                    //length is encoded on 4 bytes (0xfd header + 3 bytes indicating length)
                    length = 0xffffff & ((buf[internalPos++] & 0xff)
                        + ((buf[internalPos++] & 0xff) << 8)
                        + ((buf[internalPos++] & 0xff) << 16));
                    this.pos = internalPos;
                    this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                    return;

                  case 254:
                    //length is encoded on 9 bytes (0xfe header + 8 bytes indicating length)
                    length = (int) ((buf[internalPos++] & 0xff)
                        + ((long) (buf[internalPos++] & 0xff) << 8)
                        + ((long) (buf[internalPos++] & 0xff) << 16)
                        + ((long) (buf[internalPos++] & 0xff) << 24)
                        + ((long) (buf[internalPos++] & 0xff) << 32)
                        + ((long) (buf[internalPos++] & 0xff) << 40)
                        + ((long) (buf[internalPos++] & 0xff) << 48)
                        + ((long) (buf[internalPos++] & 0xff) << 56));
                    this.pos = internalPos;
                    this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                    return;

                  default:
                    //length is encoded on 1 bytes (is then less than 251)
                    length = type;
                    this.pos = internalPos;
                    this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                    return;

                }
            }
          }
        }
      }
    }
    this.lastValueNull = length == NULL_LENGTH ? BIT_LAST_FIELD_NULL : BIT_LAST_FIELD_NOT_NULL;
  }
1267421
public void setPosition (float x, float y, float z)
    {
        if (_px != x || _py != y || _pz != z) {
            AL10.alListener3f(AL10.AL_POSITION, _px = x, _py = y, _pz = z);
        }
    }
758443
public void set(int index, byte value) {
        Preconditions.checkState(!this.readOnly, "Cannot modify a read-only ByteArraySegment.");
        Preconditions.checkElementIndex(index, this.length, "index");
        this.array[index + this.startOffset] = value;
    }
616937
@Override
	public void setXY(int index, Point2D pt) {
		if (index < 0 || index >= m_pointCount)
			// TODO exception
			throw new IndexOutOfBoundsException();

		_verifyAllStreams();
		// AttributeStreamOfDbl v = (AttributeStreamOfDbl)
		// m_vertexAttributes[0];
		AttributeStreamOfDbl v = (AttributeStreamOfDbl) m_vertexAttributes[0];
		v.write(index * 2, pt);
		notifyModified(DirtyFlags.DirtyCoordinates);
	}
302883
public void setCurrentPos(int i)
  {

    if (!m_cacheNodes)
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");

    m_next = i;
  }
126252
@Override
	public void setMinZ(double z) {
		double o = this.maxz;
		if (o<z) {
			this.minz = o;
			this.maxz = z;
		}
		else {
			this.minz = z;
		}
	}
690008
public void set(int index, SoyData value) {
    if (index == list.size()) {
      list.add(ensureValidValue(value));
    } else {
      list.set(index, ensureValidValue(value));
    }
  }
229785
public void setIndexFields(java.util.Collection<IndexFieldStatus> indexFields) {
        if (indexFields == null) {
            this.indexFields = null;
            return;
        }

        this.indexFields = new com.amazonaws.internal.SdkInternalList<IndexFieldStatus>(indexFields);
    }
906081
@Override
	public void set(double x1, double y1, double z1) {
		this.x = x1;
		this.y = y1;
		this.z = z1;
	}
1002427
public void set(int[] indexes, int[] offsets, int[] lengths) {
        m_size = indexes.length;
        m_valuesCount = offsets.length;
        m_offsets = offsets;
        m_lengths = lengths;
        m_prefixes = new int[offsets.length];
        m_suffixes = new int[offsets.length];
        m_indexes = indexes;
    }
1047766
@Override
	public void setZ(double min, double max) {
		if (min <= max) {
			this.minzProperty.set(min);
			this.maxzProperty.set(max);
		} else {
			this.minzProperty.set(max);
			this.maxzProperty.set(min);
		}
	}