*/
  @CanIgnoreReturnValue
  PrimitiveSink putBytes(byte[] bytes);

  /**
   * Puts a chunk of an array of bytes into this sink. {@code bytes[off]} is the first byte written,
   * {@code bytes[off + len - 1]} is the last.
   *
   * @param bytes a byte array
   * @param off the start offset in the array
   * @param len the number of bytes to write
   * @return this instance

    }

    /**
     * Test getMessageByDcerpcError() with a known error code (last element).
     */
    @Test
    void testGetMessageByDcerpcError_lastElement() {
        String message = DcerpcException.getMessageByDcerpcError(DcerpcError.DCERPC_FAULT_PROTO_ERROR);
        assertEquals("DCERPC_FAULT_PROTO_ERROR", message, "Should return correct message for last element.");
    }

    /**

		} else if offsetEnd, err = strconv.ParseInt(offsetEndString, 10, 64); err != nil {
			return nil, fmt.Errorf("'%s' does not have a valid last byte position value", rangeString)
		} else if offsetEnd < 0 {
			return nil, fmt.Errorf("Last byte position is negative ('%d')", offsetEnd)
		}
	}

	switch {
	case offsetBegin > -1 && offsetEnd > -1:
		if offsetBegin > offsetEnd {

    assertThat(FluentIterable.from(list).last()).hasValue("c");
  }

  public void testLast_null() {
    List<String> list = Lists.newArrayList("a", "b", null);
    assertThrows(NullPointerException.class, () -> FluentIterable.from(list).last());
  }

  public void testLast_emptyList() {
    List<String> list = emptyList();
    assertThat(FluentIterable.from(list).last()).isAbsent();
  }

        int data1 = bb.getInt(); // first 4 bytes (little-endian)
        short data2 = bb.getShort(); // next 2 bytes (little-endian)
        short data3 = bb.getShort(); // next 2 bytes (little-endian)

        // The last 8 bytes are read as big-endian (network byte order for the high/low parts)
        ByteBuffer bb2 = ByteBuffer.wrap(bytes, 8, 8).order(java.nio.ByteOrder.BIG_ENDIAN);
        long data4 = bb2.getLong();

{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}

/// note | 注意

`data` 和 `raw_data` 是互斥的。每个 `ServerSentEvent` 上只能设置其中一个。

///

## 使用 `Last-Event-ID` 恢复 { #resuming-with-last-event-id }

当连接中断后浏览器重新连接时，会在 `Last-Event-ID` 头中发送上次收到的 `id`。

你可以将其读取为一个请求头参数，并据此从客户端离开的地方恢复流：

{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}

## 使用 POST 的 SSE { #sse-with-post }

   * nulls in the stream. This means that the method can safely be used with a stream that contains
   * nulls as long as the *last* element is *not* null.
   *
   * (To "go out of its way," the method tracks a `set` bit so that it can distinguish "the final
   * split has a last element of null, so throw NPE" from "the final split was empty, so look for an
   * element in the prior one.")
   */

     */
    public ExecJob jvmOptions(final String... options) {
        Collections.addAll(jvmOptions, options);
        return this;
    }

    /**
     * Sets the Lasta environment configuration.
     *
     * @param env the Lasta environment string
     * @return this ExecJob instance for method chaining
     */
    public ExecJob lastaEnv(final String env) {
        lastaEnv = env;
        return this;

#                                                                                    Core
#                                                                                   ======
# The mode of Lasta Di's smart-deploy, should be cool in production (e.g. hot, cool, warm)
lasta_di.smart.deploy.mode = cool

# Is development environment here? (used for various purpose, you should set false if unknown)
development.here = false

    Map<K, V> delegateMap = Maps.newHashMapWithExpectedSize(n);
    // If duplicates are allowed, this map will track the last value for each duplicated key.
    // A second pass will retain only the first entry for that key, but with this last value. The
    // value will then be replaced by null, signaling that later entries with the same key should
    // be deleted.
    Map<K, @Nullable V> duplicates = null;