From 210ede8230b2cc7f5930693ec0b1955cef95c494 Mon Sep 17 00:00:00 2001 From: orbiter Date: Fri, 30 Mar 2007 08:44:43 +0000 Subject: [PATCH] added a class for byte-array management. This was the result of a very large experiment to replace byte[] objects within kelondro. Frequent System.arraycopy are common when kelondroRow.Entry objects are handled. This class may be used to prevent this. However, experimental replacement of byte[] by kelondroByteArray in kelondroRow.Entry resulted in complete re-write of large parts of kelondro. This experiment did not completely lead to a result, because then the interface to kelondro had to be changed also from byte[] to kelondroByteArray, which may have caused a rewrite of large parts of YaCy. The experiment is therefore abanonded, but this class remains here without any function but possibly for future use. git-svn-id: https://svn.berlios.de/svnroot/repos/yacy/trunk@3531 6c8d7289-2bf4-0310-a012-ef5d649a1542 --- .../de/anomic/kelondro/kelondroByteArray.java | 202 ++++++++++++++++++ 1 file changed, 202 insertions(+) create mode 100644 source/de/anomic/kelondro/kelondroByteArray.java diff --git a/source/de/anomic/kelondro/kelondroByteArray.java b/source/de/anomic/kelondro/kelondroByteArray.java new file mode 100644 index 000000000..31beae0fe --- /dev/null +++ b/source/de/anomic/kelondro/kelondroByteArray.java @@ -0,0 +1,202 @@ +//kelondrobyteArray.java +// (C) 2007 by Michael Peter Christen; mc@anomic.de, Frankfurt a. M., Germany +// first published 30.03.2007 on http://yacy.net +// +// This is a part of YaCy, a peer-to-peer based web search engine +// +// $LastChangedDate: 2006-04-02 22:40:07 +0200 (So, 02 Apr 2006) $ +// $LastChangedRevision: 1986 $ +// $LastChangedBy: orbiter $ +// +// LICENSE +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +package de.anomic.kelondro; + +import java.io.IOException; +import java.io.UnsupportedEncodingException; + +// this class is a experimental replacement of byte[]. It should be used +// if frequent System.arraycopy usage is common for byte[] data types +// when replaced by this class, all copies share the same byte[] but can +// access a different part of the byte array + +public class kelondroByteArray { + + private byte[] buffer; + private int offset; + private int length; + + public kelondroByteArray(int initLength) { + this.buffer = new byte[initLength]; + this.length = 0; + this.offset = 0; + } + + public kelondroByteArray(byte[] bb) { + this.buffer = bb; + this.length = bb.length; + this.offset = 0; + } + + public kelondroByteArray(byte[] bb, int offset, int length) { + this.buffer = bb; + this.length = length; + this.offset = offset; + } + + public kelondroByteArray(kelondroByteArray ba, int offset, int length) { + this.buffer = ba.buffer; + this.length = length; + this.offset = ba.offset + offset; + } + + public void ensureSize(int needed) { + if (buffer.length - offset >= needed) return; + byte[] newbuffer = new byte[needed]; + System.arraycopy(buffer, offset, newbuffer, 0, length); + buffer = newbuffer; + offset = 0; + newbuffer = null; + } + + public void trim(int needed) { + if (buffer.length - offset < needed) return; + if (buffer.length - offset == length) return; + byte[] newbuffer = new byte[needed]; + System.arraycopy(buffer, offset, newbuffer, 0, length); + buffer = newbuffer; + offset = 0; + newbuffer = null; + } + + public final void removeShift(int pos, int dist, int upBound) { + assert (pos + dist >= 0) : "pos = " + pos + ", dist = " + dist; + assert (pos >= 0) : "pos = " + pos; + assert (this.offset + upBound <= buffer.length) : "upBound = " + upBound + ", buffer.length = " + buffer.length; + assert (this.offset + upBound - dist <= buffer.length) : "dist = " + dist + ", upBound = " + upBound + ", buffer.length = " + buffer.length; + System.arraycopy(buffer, this.offset + pos + dist, buffer, this.offset + pos, upBound - pos - dist); + } + + public final void swap(int i, int j, int size) { + if (this.offset + this.length + size <= buffer.length) { + // there is space in the chunkcache that we can use as buffer + System.arraycopy(buffer, this.offset + size * i, buffer, buffer.length - size, size); + System.arraycopy(buffer, this.offset + size * j, buffer, this.offset + size * i, size); + System.arraycopy(buffer, buffer.length - size, buffer, this.offset + size * j, size); + } else { + // allocate a chunk to use as buffer + byte[] a = new byte[size]; + System.arraycopy(buffer, this.offset + size * i, a, 0, size); + System.arraycopy(buffer, this.offset + size * j, buffer, this.offset + size * i, size); + System.arraycopy(a, 0, buffer, this.offset + size * j, size); + } + } + + public void clear() { + length = 0; + offset = 0; + } + + public int length() { + return length; + } + + public byte[] asBytes() { + byte[] tmp = new byte[length]; + System.arraycopy(buffer, offset, tmp, 0, length); + return tmp; + } + + public byte readByte(int pos) { + return buffer[this.offset + pos]; + } + + public long readLongB64e(int pos, int length) { + return kelondroBase64Order.enhancedCoder.decodeLong(buffer, this.offset + pos, length); + } + + public long readLongB256(int pos, int length) { + return kelondroNaturalOrder.decodeLong(buffer, this.offset + pos, length); + } + + public byte[] readBytes(int from_pos, int length) { + byte[] buf = new byte[length]; + System.arraycopy(buffer, this.offset + from_pos, buf, 0, length); + return buf; + } + + public String readString(int from_pos, int length) { + return new String(buffer, this.offset + from_pos, length); + } + + public String readString(int from_pos, int length, String encoding) { + try { + return new String(buffer, this.offset + from_pos, length, encoding); + } catch (UnsupportedEncodingException e) { + return ""; + } + } + + public void readToRA(int from_pos, kelondroRA to_file, int len) throws IOException { + to_file.write(this.buffer, from_pos, len); + } + + public void write(int to_position, byte b) { + buffer[this.offset + to_position] = b; + } + + public void write(int to_position, byte[] from_array, int from_offset, int from_length) { + System.arraycopy(from_array, from_offset, this.buffer, this.offset + to_position, from_length); + } + + public void write(int to_position, kelondroByteArray from_array) { + System.arraycopy(from_array.buffer, from_array.offset, this.buffer, this.offset + to_position, from_array.length); + } + + public void write(int to_position, kelondroByteArray from_array, int from_offset, int from_length) { + System.arraycopy(from_array.buffer, from_array.offset + from_offset, this.buffer, this.offset + to_position, from_length); + } + + public int write(int to_position, kelondroRA from_file, int len) throws IOException { + if (len == 0) return 0; + return from_file.read(this.buffer, to_position, len); + } + + public static boolean equals(byte[] buffer, byte[] pattern) { + return equals(buffer, 0, pattern); + } + + public static boolean equals(byte[] buffer, int offset, byte[] pattern) { + // compares two byte arrays: true, if pattern appears completely at offset position + if (buffer.length < offset + pattern.length) return false; + for (int i = 0; i < pattern.length; i++) if (buffer[offset + i] != pattern[i]) return false; + return true; + } + + public void reset() { + this.length = 0; + this.offset = 0; + } + + public int compareTo(kelondroByteArray b, kelondroOrder order) { + return order.compare(this.buffer, this.offset, this.length, b.buffer, b.offset, b.length); + } + + public int compareTo(int aoffset, int alength, kelondroByteArray b, int boffset, int blength, kelondroOrder order) { + return order.compare(this.buffer, this.offset + aoffset, alength, b.buffer, b.offset + boffset, blength); + } +}