Method predictSerializedSize

src/MultiAction.java:146–213

Predicts a lower bound on the serialized size of this RPC. This is to avoid using a dynamic buffer, to avoid re-sizing the buffer. Since we use a static buffer, if the prediction is wrong and turns out to be less than what we need, there will be an exception which will prevent the RPC from being ser

(final byte server_version)

   * @param server_version What RPC protocol version the server is running.
   */
  private int predictSerializedSize(final byte server_version) {
    // See the comment in serialize() about the for loop that follows.
    int size = 0;
    size += 4;  // int:  Number of parameters.
    size += 1;  // byte: Type of the 1st parameter.
    size += 1;  // byte: Type again (see HBASE-2877).
    size += 4;  // int:  How many regions do we want to affect?

    // Are we serializing a `multi' RPC, or `multiPut'?
    final boolean use_multi = method(server_version) == MULTI;

    BatchableRpc prev = PutRequest.EMPTY_PUT;
    for (final BatchableRpc rpc : batch) {
      final byte[] region_name = rpc.getRegion().name();
      final boolean new_region = !Bytes.equals(prev.getRegion().name(),
                                               region_name);
      final byte[] family = rpc.family();
      final boolean new_key = (new_region
                               || prev.code() != rpc.code()
                               || !Bytes.equals(prev.key, rpc.key)
                               || family == DeleteRequest.WHOLE_ROW);
      final boolean new_family = new_key || !Bytes.equals(prev.family(),
                                                          family);

      if (new_region) {
        size += 3;  // vint: region name length (3 bytes => max length = 32768).
        size += region_name.length;  // The region name.
        size += 4;  // int:  How many RPCs for this region.
      }

      final int key_length = rpc.key.length;

      if (new_key) {
        if (use_multi) {
          size += 4;  // int: Number of "attributes" for the last key (none).
          size += 4;  // Index of this `action'.
          size += 3;  // 3 bytes to serialize `null'.

          size += 1;  // byte: Type code for `Action'.
          size += 1;  // byte: Type code again (see HBASE-2877).

          size += 1;  // byte: Code for a `Row' object.
          size += 1;  // byte: Code for a `Put' object.
        }

        size += 1;  // byte: Version of Put.
        size += 3;  // vint: row key length (3 bytes => max length = 32768).
        size += key_length;  // The row key.
        size += 8;  // long: Timestamp.
        size += 8;  // long: Lock ID.
        size += 1;  // bool: Whether or not to write to the WAL.
        size += 4;  // int:  Number of families for which we have edits.
      }

      if (new_family) {
        size += 1;  // vint: Family length (guaranteed on 1 byte).
        size += family.length;  // The family.
        size += 4;  // int:  Number of KeyValues that follow.