Source code
package com.google.common.io;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.DataInput;
import java.io.IOException;
import org.jspecify.annotations.Nullable;
/**
* An extension of {@code DataInput} for reading from in-memory byte arrays; its methods offer
* identical functionality but do not throw {@link IOException}.
*
* <p><b>Warning:</b> The caller is responsible for not attempting to read past the end of the
* array. If any method encounters the end of the array prematurely, it throws {@link
* IllegalStateException} to signify <i>programmer error</i>. This behavior is a technical violation
* of the supertype's contract, which specifies a checked exception.
*
* @author Kevin Bourrillion
* @since 1.0
*/
@J2ktIncompatible
@GwtIncompatible
public interface ByteArrayDataInput extends DataInput {
@Override
void readFully(byte[] b);
@Override
void readFully(byte[] b, int off, int len);
// not guaranteed to skip n bytes so result should NOT be ignored
// use ByteStreams.skipFully or one of the read methods instead
@Override
int skipBytes(int n);
@CanIgnoreReturnValue // to skip a byte
@Override
boolean readBoolean();
@CanIgnoreReturnValue // to skip a byte
@Override
byte readByte();
@CanIgnoreReturnValue // to skip a byte
@Override
int readUnsignedByte();
@CanIgnoreReturnValue // to skip some bytes
@Override
short readShort();
@CanIgnoreReturnValue // to skip some bytes
@Override
int readUnsignedShort();
@CanIgnoreReturnValue // to skip some bytes
@Override
char readChar();
@CanIgnoreReturnValue // to skip some bytes
@Override
int readInt();
@CanIgnoreReturnValue // to skip some bytes
@Override
long readLong();
@CanIgnoreReturnValue // to skip some bytes
@Override
float readFloat();
@CanIgnoreReturnValue // to skip some bytes
@Override
double readDouble();
@CanIgnoreReturnValue // to skip a line
@Override
@Nullable String readLine();
@CanIgnoreReturnValue // to skip a field
@Override
String readUTF();
}
Run 1
The code is highly readable due to its logical structure and clear intent. The interface declaration is straightforward, with a concise yet informative Javadoc explaining the behavior and contract deviations. Method declarations are flat, with no nesting, and each method is presented on a single line, making the structure easy to scan. The use of @Override and @CanIgnoreReturnValue annotations is consistent, and the brief comments for each method clarify the intended use when return values are ignored. Imports are organized and limited. The code avoids unnecessary length, with only essential methods and documentation. Reading flow is natural, grouping related read methods logically. Overall, this is an exemplary implementation of a well-documented, minimal interface.
Run 2
The code is highly readable due to its clear structure and consistent formatting. The interface methods are logically grouped and each declaration is concise, adhering to one action per line. The javadoc provides explicit intent, especially regarding the behavioral difference from DataInput. Minimal nesting and a flat interface hierarchy contribute to easy scanning. Annotations like @CanIgnoreReturnValue are consistently applied with brief, helpful comments. The only minor drawback is the slight verbosity of repeated annotations, but this is justified and does not impede readability.
Run 3
The code is highly readable. It uses a clear logical structure with related methods grouped together, and the interface declaration is flat with no nesting. Each method is on a single line with a succinct annotation comment explaining the return value's purpose, enhancing clarity. The Javadoc provides a thorough yet concise explanation of the class's behavior and contract deviation. The use of @Override annotations and consistent formatting makes the intent unambiguous. Minor deductions could be for slightly verbose repetitive comments, but overall the code is clean, well-documented, and easy to scan.
Run 1
Code Structure: The interface is logically organized, with related read methods grouped in a familiar sequence. Nesting: The code is flat, with no nested control flow. Clarity of intent: Descriptive method names and class documentation clearly explain the purpose, exception behavior, and caller responsibilities; standard abbreviated parameters are slightly less explicit. Code length: Concise for an interface, though repeated annotations and similar comments add minor visual repetition. Action granularity: Each method declaration occupies its own line, with annotations clearly associated with it. Reading flow: Consistent spacing and formatting make scanning natural; the lack of separation between the package declaration and imports is a minor presentation issue.
Run 2
Code Structure: A well-organized interface with consistent method declarations and logical grouping of related reads. Nesting: Completely flat apart from the interface scope. Clarity of intent: The Javadoc clearly explains the purpose, exception behavior, and caller responsibilities; familiar DataInput method names reinforce intent, though abbreviated parameter names are less descriptive. Code length: Concise for the API it exposes; repeated annotations and comments add some visual noise but serve useful purposes. Action granularity: Each declaration occupies its own line, with no combined operations. Reading flow: Consistent spacing and annotation placement make the interface easy to scan, although blank lines separating the package and imports would improve the header.
Run 3
Code Structure: A well-organized interface with consistently formatted declarations and related methods grouped logically. Nesting: Flat, with no nested control flow. Clarity of intent: The Javadoc clearly explains the purpose, exception behavior, and caller responsibilities; familiar DataInput method names and annotations reinforce intent. Code length: Concise for the API exposed, though repeated annotations and skip comments add slight visual repetition. Action granularity: Each method declaration occupies its own line, with annotations clearly separated. Reading flow: Natural progression from bulk reads and skipping to primitive and string reads, aided by whitespace. Minor readability limitations include abbreviated parameter names and the lack of spacing between the package declaration and imports.