@Override public byte byteAt(int offset) { return input.byteAt(offset); } });
/** * Gets the byte at the given index. * Throws {@link ArrayIndexOutOfBoundsException} for backwards-compatibility * reasons although it would more properly be {@link * IndexOutOfBoundsException}. * * @param index index of byte * @return the value * @throws ArrayIndexOutOfBoundsException {@code index} is < 0 or >= size */ @Override public byte byteAt(int index) { checkIndex(index, totalLength); // Find the relevant piece by recursive descent if (index < leftLength) { return left.byteAt(index); } return right.byteAt(index - leftLength); }
/** * Gets the byte at the given index. * Throws {@link ArrayIndexOutOfBoundsException} for backwards-compatibility * reasons although it would more properly be {@link * IndexOutOfBoundsException}. * * @param index index of byte * @return the value * @throws ArrayIndexOutOfBoundsException {@code index} is < 0 or >= size */ @Override public byte byteAt(int index) { if (index < 0) { throw new ArrayIndexOutOfBoundsException("Index < 0: " + index); } if (index > totalLength) { throw new ArrayIndexOutOfBoundsException( "Index > length: " + index + ", " + totalLength); } byte result; // Find the relevant piece by recursive descent if (index < leftLength) { result = left.byteAt(index); } else { result = right.byteAt(index - leftLength); } return result; }
@Override public byte nextByte() { try { return byteAt(position++); } catch (IndexOutOfBoundsException e) { throw new NoSuchElementException(e.getMessage()); } }
@Override public String toString() { ToStringHelper toStringHelper = MoreObjects.toStringHelper(this); StringBuilder stBuilder = new StringBuilder(); for (int i = 0; i < byteString.size(); i++) { stBuilder.append(String.format("%02x", byteString.byteAt(i))); } return toStringHelper.add("bytes", stBuilder.toString()).toString(); }
@Override public String toString() { ToStringHelper toStringHelper = MoreObjects.toStringHelper(this); StringBuilder stBuilder = new StringBuilder(); for (int i = 0; i < Math.min(256, byteString.size()); i++) { stBuilder.append(String.format("%02x", byteString.byteAt(i))); } if (byteString.size() > 256) { stBuilder.append("..."); } return toStringHelper.add("bytes", stBuilder.toString()).toString(); }
@Override public String toString() { ToStringHelper toStringHelper = MoreObjects.toStringHelper(this); StringBuilder stBuilder = new StringBuilder(); for (int i = 0; i < Math.min(256, byteString.size()); i++) { stBuilder.append(String.format("%02x", byteString.byteAt(i))); } if (byteString.size() > 256) { stBuilder.append("..."); } return toStringHelper.add("bytes", stBuilder.toString()).toString(); }
@Override public int compare(ByteString o1, ByteString o2) { int sizeA = o1.size(); int sizeB = o2.size(); int shortestSize = Math.min(sizeA, sizeB); for (int i = 0; i < shortestSize; i++) { int byteA = o1.byteAt(i) & 0xff; int byteB = o2.byteAt(i) & 0xff; if (byteA != byteB) { return byteA < byteB ? -1 : 1; } } if (sizeA == sizeB) { return 0; } return sizeA < sizeB ? -1 : 1; } }
final StringBuilder builder = new StringBuilder(input.size()); for (int i = 0; i < input.size(); i++) { final byte b = input.byteAt(i); switch (b) {
private int compareBlobs(Value left, Value right) { ByteString leftBytes = left.getBytesValue(); ByteString rightBytes = right.getBytesValue(); int size = Math.min(leftBytes.size(), rightBytes.size()); for (int i = 0; i < size; i++) { // Make sure the bytes are unsigned int thisByte = leftBytes.byteAt(i) & 0xff; int otherByte = rightBytes.byteAt(i) & 0xff; if (thisByte < otherByte) { return -1; } else if (thisByte > otherByte) { return 1; } // Byte values are equal, continue with comparison } return Integer.compare(leftBytes.size(), rightBytes.size()); }
/** Lexicographically compares this row's key to another row's key. */ @Override public int compareTo(@Nonnull Row row) { int sizeA = getKey().size(); int sizeB = row.getKey().size(); int size = Math.min(sizeA, sizeB); for (int i = 0; i < size; i++) { int byteA = getKey().byteAt(i) & 0xff; int byteB = row.getKey().byteAt(i) & 0xff; if (byteA == byteB) { continue; } else { return byteA < byteB ? -1 : 1; } } if (sizeA == sizeB) { return 0; } return sizeA < sizeB ? -1 : 1; } }
int pos = 0; for (int i = 0; i < input.size(); i++) { byte c = input.byteAt(i); if (c == '\\') { if (i + 1 < input.size()) { ++i; c = input.byteAt(i); if (isOctal(c)) { if (i + 1 < input.size() && isOctal(input.byteAt(i + 1))) { ++i; code = code * 8 + digitValue(input.byteAt(i)); if (i + 1 < input.size() && isOctal(input.byteAt(i + 1))) { ++i; code = code * 8 + digitValue(input.byteAt(i)); if (i + 1 < input.size() && isHex(input.byteAt(i + 1))) { ++i; code = digitValue(input.byteAt(i)); } else { throw new InvalidEscapeSequenceException( "Invalid escape sequence: '\\x' with no digits"); if (i + 1 < input.size() && isHex(input.byteAt(i + 1))) { ++i; code = code * 16 + digitValue(input.byteAt(i));
int pos = 0; for (int i = 0; i < input.size(); i++) { byte c = input.byteAt(i); if (c == '\\') { if (i + 1 < input.size()) { ++i; c = input.byteAt(i); if (isOctal(c)) { if (i + 1 < input.size() && isOctal(input.byteAt(i + 1))) { ++i; code = code * 8 + digitValue(input.byteAt(i)); if (i + 1 < input.size() && isOctal(input.byteAt(i + 1))) { ++i; code = code * 8 + digitValue(input.byteAt(i)); if (i + 1 < input.size() && isHex(input.byteAt(i + 1))) { ++i; code = digitValue(input.byteAt(i)); } else { throw new InvalidEscapeSequenceException( "Invalid escape sequence: '\\x' with no digits"); if (i + 1 < input.size() && isHex(input.byteAt(i + 1))) { ++i; code = code * 16 + digitValue(input.byteAt(i));
private <T> Map<Class<? extends T>, Integer> applySerializationInfo(List<NetData.SerializationInfo> infoList, ClassLibrary<T> classLibrary) { Map<Class<? extends T>, Integer> idTable = Maps.newHashMap(); for (NetData.SerializationInfo info : infoList) { ClassMetadata<? extends T, ?> metadata = classLibrary.getMetadata(new SimpleUri(info.getName())); if (metadata != null) { idTable.put(metadata.getType(), info.getId()); for (int i = 0; i < info.getFieldIds().size(); ++i) { FieldMetadata<?, ?> field = metadata.getField(info.getFieldName(i)); if (field != null) { field.setId(info.getFieldIds().byteAt(i)); } else { logger.error("Server has unknown field '{}' on '{}'", info.getFieldName(i), info.getName()); } } } else { logger.error("Server has unknown class '{}'", info.getName()); } } return idTable; }
private Event deserializeOnto(Event targetEvent, EntityData.Event eventData, EventMetadata<? extends Event> eventMetadata) { Serializer serializer = typeSerializationLibrary.getSerializerFor(eventMetadata); for (int i = 0; i < eventData.getFieldIds().size(); ++i) { byte fieldId = eventData.getFieldIds().byteAt(i); ReplicatedFieldMetadata<?, ?> fieldInfo = eventMetadata.getField(fieldId); if (fieldInfo == null) { logger.error("Unable to serialize field {}, out of bounds", fieldId); continue; } if (fieldInfo.isReplicated()) { serializer.deserializeOnto(targetEvent, fieldInfo, new ProtobufPersistedData(eventData.getFieldValue(i)), deserializationContext); } } return targetEvent; }
if (metadata == null) { logger.warn("Skipping unknown component {}", componentId); fieldPos += UnsignedBytes.toInt(entityData.getComponentFieldCounts().byteAt(componentIndex)); continue; fieldPos += UnsignedBytes.toInt(entityData.getComponentFieldCounts().byteAt(componentIndex)); continue; for (int fieldIndex = 0; fieldIndex < UnsignedBytes.toInt(entityData.getComponentFieldCounts().byteAt(componentIndex)); ++fieldIndex) { byte fieldId = entityData.getFieldIds().byteAt(fieldPos); ReplicatedFieldMetadata fieldMetadata = metadata.getField(fieldId); if (fieldMetadata != null && fieldCheck.shouldDeserialize(metadata, fieldMetadata)) {
public static ByteStringRange prefix(ByteString prefix) { if (prefix.isEmpty()) { return unbounded(); } int offset = prefix.size() - 1; int curByte = 0xFF; while (offset >= 0) { curByte = prefix.byteAt(offset) & 0xFF; if (curByte != 0xFF) { break; } offset--; } if (offset < 0) { // We got an 0xFFFF... (only FFs) stopRow value which is // the last possible prefix before the end of the table. // So set it to stop at the 'end of the table' return unbounded().startClosed(prefix); } ByteString endPrefix = offset == 0 ? ByteString.EMPTY : prefix.substring(0, offset); ByteString endSuffix = UnsafeByteOperations.unsafeWrap(new byte[] {(byte) (curByte + 1)}); ByteString end = endPrefix.concat(endSuffix); ByteStringRange range = ByteStringRange.unbounded().startClosed(prefix); if (!end.isEmpty()) { range.endOpen(end); } return range; }
@Override public byte byteAt(int offset) { return input.byteAt(offset); } });
@Override public String toString() { ToStringHelper toStringHelper = MoreObjects.toStringHelper(this); StringBuilder stBuilder = new StringBuilder(); for (int i = 0; i < Math.min(256, byteString.size()); i++) { stBuilder.append(String.format("%02x", byteString.byteAt(i))); } if (byteString.size() > 256) { stBuilder.append("..."); } return toStringHelper.add("bytes", stBuilder.toString()).toString(); }
@Override public String toString() { ToStringHelper toStringHelper = MoreObjects.toStringHelper(this); StringBuilder stBuilder = new StringBuilder(); for (int i = 0; i < Math.min(256, byteString.size()); i++) { stBuilder.append(String.format("%02x", byteString.byteAt(i))); } if (byteString.size() > 256) { stBuilder.append("..."); } return toStringHelper.add("bytes", stBuilder.toString()).toString(); }