import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
private Set<byte[]> extend(final byte[] lhs, final byte[] rhs) {
  final Set<byte[]> extendedRhsCandidates =
      new ObjectOpenCustomHashSet<>(ByteArrays.HASH_STRATEGY);
  if (lhs.length + rhs.length > this.level - 1) {
    // extended candidates would have more columns than this level allows,
    // return empty extended candidates
    return extendedRhsCandidates;
  }
  for (final byte[] singleColumn : this.singleColumnPermutations) {
    if (ByteArrayPermutations.disjoint(singleColumn, lhs)
        && ByteArrayPermutations.disjoint(singleColumn, rhs)) {
      extendedRhsCandidates.add(ByteArrayPermutations.join(rhs, singleColumn));
    }
  }
  return extendedRhsCandidates;
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
public void append(byte b) {
    if (size >= bytes.length - 1) {
        bytes = ByteArrays.grow(bytes, bytes.length + 1024);
    }
    switch (b) {
        case -1:
            bytes[size++] = -1;
            bytes[size++] = MINUS_CODE;
            break;
        case (byte) '\n':
            bytes[size++] = -1;
            bytes[size++] = NL_CODE;
            break;
        case (byte) '\r':
            bytes[size++] = -1;
            bytes[size++] = RETURN_CODE;
            break;
        default:
            bytes[size++] = b;
    }

}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
private void buildPrefixBlocks() {
  this.prefixBlocks = new Object2ObjectOpenCustomHashMap<>(ByteArrays.HASH_STRATEGY);

  for (final byte[] permutation : this.previousLevelCandidates) {
    // prefix is the emtpy array for permutations of size 1 (level 1)
    final byte[] prefix = ByteArrayPermutations.prefix(permutation);

    if (this.prefixBlocks.get(prefix) == null) {
      this.prefixBlocks.put(prefix, new ArrayList<byte[]>());
    }
    this.prefixBlocks.get(prefix).add(permutation);
  }
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
protected void initializePartitions() throws AlgorithmExecutionException {
  this.permutationToPartition = new Object2ObjectOpenCustomHashMap<>(ByteArrays.HASH_STRATEGY);

  // create partitions for level 1
  for (final int columnIndex : this.columnIndices) {
    final byte[] singleColumnPermutation = {(byte) columnIndex};

    final SortedPartition partition =
        SortedPartitionCreator.createPartition(this.dataByColumns.get(columnIndex),
            this.types.get(columnIndex));

    this.permutationToPartition.put(singleColumnPermutation, partition);
  }

}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
/** Wraps a byte-array fragment into this byte-array character sequence.
 *
 * @param b a byte array.
 * @param offset the first valid byte in <code>b</code>.
 * @param length the number of valid bytes in <code>b</code>, starting at <code>offset</code>.
 * @return this byte-array character sequence.
 */
public ByteArrayCharSequence wrap(final byte[] b, int offset, int length) {
	ByteArrays.ensureOffsetLength(b, offset, length);
	this.b = b;
	this.offset = offset;
	this.length = length;
	return this;
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
/** Dequeues an object from the queue in FIFO fashion. */
@SuppressWarnings("unchecked")
public synchronized T dequeue() throws IOException {
	final int length = byteDiskQueue.dequeueInt();
	fbaos.array = ByteArrays.grow(fbaos.array, length);
	byteDiskQueue.dequeue(fbaos.array, 0, length);
	size--;
	try {
		return (T)BinIO.loadObject(new FastByteArrayInputStream(fbaos.array, 0, length));
	}
	catch (final ClassNotFoundException e) {
		throw new RuntimeException(e.getMessage(), e);
	}
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
public boolean readLineFrom(FastBufferedInputStream stream) throws IOException {
    int start = 0, len;
    while ((len = stream.readLine(bytes, start, bytes.length - start)) == bytes.length - start) {
        start += len;
        bytes = ByteArrays.grow(bytes, bytes.length + 1024);
    }
    size = start + Math.max(len, 0);
    return !(size == 0 && len < 0);
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
private void generateNextLevel() {

    long time = System.currentTimeMillis();

    this.previousLevelCandidates = this.levelCandidates;
    this.levelCandidates = new ArrayList<>();

    this.buildPrefixBlocks();

    System.gc();

    this.logger.debug("PREFIX_BLOCKS in level {}: {} ", this.level, this.prettyPrintPrefixBlocks());

    for (final List<byte[]> candidatesWithSamePrefix : this.prefixBlocks.values()) {
      if (candidatesWithSamePrefix.size() < 2) {
        break;
      }
      for (final byte[] candidate : candidatesWithSamePrefix) {
        for (final byte[] candidateForJoin : candidatesWithSamePrefix) {
          if (Arrays.equals(candidate, candidateForJoin)) {
            continue;
          }

          final byte[] joinedCandidate = ByteArrayPermutations.join(candidate, candidateForJoin);
          this.levelCandidates.add(joinedCandidate);
        }
      }
    }
    this.logger.debug("Generated level {}", this.level + 1);
    this.logger.debug("Level {} candidates: {}", (this.level + 1),
        ByteArrayPermutations.permutationListToIntegerString(this.levelCandidates));
    if (this.level > 1 && !this.levelCandidates.isEmpty()) {
      for (final byte[] newLhs : this.previousLevelCandidates) {
        this.logger
            .debug(
                "After generating level {}. Adding {} as an lhs to the candidate set for the next level.",
                this.level + 1, ByteArrayPermutations.permutationToIntegerString(newLhs));
        this.currentRhsCandidateSet.put(newLhs, new ObjectOpenCustomHashSet<byte[]>(
            ByteArrays.HASH_STRATEGY));
      }
    }

    time = System.currentTimeMillis() - time;
    this.statistics.setGenNextTime(this.statistics.getGenNextTime() + time);

  }
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
/** Creates a new empty byte-array character sequence.
 */
public ByteArrayCharSequence() {
	this(ByteArrays.EMPTY_ARRAY);
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
@Override
public void sortAscending() {
    ByteArrays.mergeSort(data.elements());
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
@Override
public void sortDescending() {
    ByteArrays.mergeSort(data.elements(), reverseByteComparator);
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
/** Ensures that the length of the backing array is equal to {@link #length}. */
public void trim() {
	array = ByteArrays.trim( array, length );
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
public void write( final int b ) {
	if ( position >= array.length ) array = ByteArrays.grow( array, position + 1, length );
	array[ position++ ] = (byte)b;
	if ( length < position ) length = position;
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
/** Creates a file-lines collection for the specified filename with the specified encoding, buffer size and terminator set.
 *
 * @param filename a filename.
 * @param encoding an encoding.
 * @param bufferSize the buffer size for {@link FastBufferedInputStream}.
 * @param terminators a set of line terminators.
 */
public FileLinesList(final CharSequence filename, final String encoding, final int bufferSize, final EnumSet<FastBufferedInputStream.LineTerminator> terminators) throws IOException {
	this.bufferSize = bufferSize;
	this.terminators = terminators;
	this.filename = filename.toString();

	inputStream = new FastBufferedInputStream(new FileInputStream(this.filename), bufferSize);
	decoder = (charset = Charset.forName(encoding)).newDecoder();
	byte[] array = new byte[16];
	int count = 0, start, len;

	for(;;) {
		start = 0;
		while((len = inputStream.readLine(array, start, array.length - start, terminators)) == array.length - start) {
			start += len;
			array = ByteArrays.grow(array, array.length + 1);
		};

		if (len != -1) count++;
		else break;
	}

	size = count;
	byteBuffer = ByteBuffer.wrap(array);
	charBuffer = CharBuffer.wrap(new char[array.length]);

	inputStream.position(0);
	borders = new EliasFanoMonotoneLongBigList(count, inputStream.length(), new LongIterator() {
		long pos = 0;
		byte[] buffer = byteBuffer.array();

		@Override
		public boolean hasNext() {
			return pos < size;
		}

		@Override
		public long nextLong() {
			if (! hasNext()) throw new NoSuchElementException();
			pos++;
			try {
				final long result = inputStream.position();
				inputStream.readLine(buffer, terminators);
				return result;
			}
			catch (final IOException e) {
				throw new RuntimeException(e);
			}
		}
	});
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
/** Creates a file-lines collection for the specified filename with the specified encoding, buffer size and terminator set.
 *
 * @param filename a filename.
 * @param encoding an encoding.
 * @param bufferSize the buffer size for {@link FastBufferedInputStream}.
 * @param terminators a set of line terminators.
 */
public FileLinesBigList(final CharSequence filename, final String encoding, final int bufferSize, final EnumSet<FastBufferedInputStream.LineTerminator> terminators) throws IOException {
	this.bufferSize = bufferSize;
	this.terminators = terminators;
	this.filename = filename.toString();

	inputStream = new FastBufferedInputStream(new FileInputStream(this.filename), bufferSize);
	decoder = (charset = Charset.forName(encoding)).newDecoder();
	byte[] array = new byte[16];
	long count = 0;
	int start, len;

	for(;;) {
		start = 0;
		while((len = inputStream.readLine(array, start, array.length - start, terminators)) == array.length - start) {
			start += len;
			array = ByteArrays.grow(array, array.length + 1);
		};

		if (len != -1) count++;
		else break;
	}

	size = count;
	byteBuffer = ByteBuffer.wrap(array);
	charBuffer = CharBuffer.wrap(new char[array.length]);

	inputStream.position(0);
	borders = new EliasFanoMonotoneLongBigList(count, inputStream.length(), new LongIterator() {
		long pos = 0;
		byte[] buffer = byteBuffer.array();

		@Override
		public boolean hasNext() {
			return pos < size;
		}

		@Override
		public long nextLong() {
			if (! hasNext()) throw new NoSuchElementException();
			pos++;
			try {
				final long result = inputStream.position();
				inputStream.readLine(buffer, terminators);
				return result;
			}
			catch (final IOException e) {
				throw new RuntimeException(e);
			}
		}
	});
}
 

import it.unimi.dsi.fastutil.bytes.ByteArrays; //导入依赖的package包/类
public void setContentOf(LineBytesBuffer feature) {
    size = feature.size;
    bytes = ByteArrays.ensureCapacity(bytes, size);
    System.arraycopy(feature.bytes, 0, bytes, 0, size);
}