/** Finishes the index creation. */
void finish() {
if (reorder == null) return;
for (int i = 1; i < reorder.size(); i++) {
if (reorder.get(i)) Arrays.sort(idsList.get(i), 0, lenList.get(i));
}
reorder = null;
}
/**
* Scans an external ID.
*
* @param f full flag
* @param r root flag
* @return id
* @throws IOException I/O exception
*/
private byte[] externalID(final boolean f, final boolean r) throws IOException {
byte[] cont = null;
final boolean pub = consume(PUBLIC);
if (pub || consume(SYSTEM)) {
checkS();
if (pub) {
pubidLit();
if (f) checkS();
}
final int qu = consume(); // [11]
if (qu == '\'' || qu == '"') {
int ch;
final TokenBuilder tok = new TokenBuilder();
while ((ch = nextChar()) != qu) tok.add(ch);
if (!f) return null;
final String name = string(tok.finish());
if (!dtd && r) return cont;
final XMLInput tin = input;
try {
final IO file = input.io().merge(name);
cont = file.read();
} catch (final IOException ex) {
Util.debug(ex);
// skip unknown DTDs/entities
cont = new byte[] {'?'};
}
input = new XMLInput(new IOContent(cont, name));
if (consume(XDECL)) {
check(XML);
s();
if (version()) checkS();
s();
if (encoding() == null) error(TEXTENC);
ch = nextChar();
if (s(ch)) ch = nextChar();
if (ch != '?') error(WRONGCHAR, '?', ch);
ch = nextChar();
if (ch != '>') error(WRONGCHAR, '>', ch);
cont = Arrays.copyOfRange(cont, input.pos(), cont.length);
}
s();
if (r) {
extSubsetDecl();
if (!consume((char) 0)) error(INVEND);
}
input = tin;
} else {
if (f) error(SCANQUOTE, (char) qu);
prev(1);
}
}
return cont;
}
/**
* Sets the output text.
*
* @param text output text
* @param size text size
*/
public final void setText(final byte[] text, final int size) {
byte[] txt = text;
if (Token.contains(text, '\r')) {
// remove carriage returns
int ns = 0;
for (int r = 0; r < size; ++r) {
final byte b = text[r];
if (b != '\r') text[ns++] = b;
}
// new text is different...
txt = Arrays.copyOf(text, ns);
} else if (text.length != size) {
txt = Arrays.copyOf(text, size);
}
if (editor.text(txt)) {
if (hist != null) hist.store(txt, editor.pos(), 0);
}
if (isShowing()) resizeCode.invokeLater();
}
/**
* Adds values to the index.
*
* @param key key to be indexed
* @param vals sorted values
*/
void add(final byte[] key, final int... vals) {
// token index: add values. otherwise, reference existing values
final int id = type == IndexType.TOKEN ? values.put(key) : values.id(key), vl = vals.length;
// updatable index: if required, resize existing arrays
while (idsList.size() < id + 1) idsList.add(null);
if (lenList.size() < id + 1) lenList.set(id, 0);
final int len = lenList.get(id), size = len + vl;
int[] ids = idsList.get(id);
if (ids == null) {
ids = vals;
} else {
if (ids.length < size) ids = Arrays.copyOf(ids, Array.newSize(size));
System.arraycopy(vals, 0, ids, len, vl);
if (ids[len - 1] > vals[0]) {
if (reorder == null) reorder = new BoolList(values.size());
reorder.set(id, true);
}
}
idsList.set(id, ids);
lenList.set(id, size);
}
@Override
public void insert(final int pre, final byte[] entries) {
final int nnew = entries.length;
if (nnew == 0) return;
dirty();
// number of records to be inserted
final int nr = nnew >>> IO.NODEPOWER;
int split = 0;
if (used == 0) {
// special case: insert new data into first block if database is empty
readPage(0);
usedPages.set(0);
++used;
} else if (pre > 0) {
// find the offset within the block where the new records will be inserted
split = cursor(pre - 1) + IO.NODESIZE;
} else {
// all insert operations will add data after first node.
// i.e., there is no "insert before first document" statement
throw Util.notExpected("Insertion at beginning of populated table.");
}
// number of bytes occupied by old records in the current block
final int nold = npre - fpre << IO.NODEPOWER;
// number of bytes occupied by old records which will be moved at the end
final int moved = nold - split;
// special case: all entries fit in the current block
Buffer bf = bm.current();
if (nold + nnew <= IO.BLOCKSIZE) {
Array.move(bf.data, split, nnew, moved);
System.arraycopy(entries, 0, bf.data, split, nnew);
bf.dirty = true;
// increment first pre-values of blocks after the last modified block
for (int i = page + 1; i < used; ++i) fpres[i] += nr;
// update cached variables (fpre is not changed)
npre += nr;
meta.size += nr;
return;
}
// append old entries at the end of the new entries
final byte[] all = new byte[nnew + moved];
System.arraycopy(entries, 0, all, 0, nnew);
System.arraycopy(bf.data, split, all, nnew, moved);
// fill in the current block with new entries
// number of bytes which fit in the first block
int nrem = IO.BLOCKSIZE - split;
if (nrem > 0) {
System.arraycopy(all, 0, bf.data, split, nrem);
bf.dirty = true;
}
// number of new required blocks and remaining bytes
final int req = all.length - nrem;
int needed = req / IO.BLOCKSIZE;
final int remain = req % IO.BLOCKSIZE;
if (remain > 0) {
// check if the last entries can fit in the block after the current one
if (page + 1 < used) {
final int o = occSpace(page + 1) << IO.NODEPOWER;
if (remain <= IO.BLOCKSIZE - o) {
// copy the last records
readPage(page + 1);
bf = bm.current();
System.arraycopy(bf.data, 0, bf.data, remain, o);
System.arraycopy(all, all.length - remain, bf.data, 0, remain);
bf.dirty = true;
// reduce the pre value, since it will be later incremented with nr
fpres[page] -= remain >>> IO.NODEPOWER;
// go back to the previous block
readPage(page - 1);
} else {
// there is not enough space in the block - allocate a new one
++needed;
}
} else {
// this is the last block - allocate a new one
++needed;
}
}
// number of expected blocks: existing blocks + needed block - empty blocks
final int exp = blocks + needed - (blocks - used);
if (exp > fpres.length) {
// resize directory arrays if existing ones are too small
final int ns = Math.max(fpres.length << 1, exp);
fpres = Arrays.copyOf(fpres, ns);
pages = Arrays.copyOf(pages, ns);
}
// make place for the blocks where the new entries will be written
Array.move(fpres, page + 1, needed, used - page - 1);
Array.move(pages, page + 1, needed, used - page - 1);
// write the all remaining entries
while (needed-- > 0) {
freeBlock();
nrem += write(all, nrem);
fpres[page] = fpres[page - 1] + IO.ENTRIES;
pages[page] = (int) bm.current().pos;
}
// increment all fpre values after the last modified block
for (int i = page + 1; i < used; ++i) fpres[i] += nr;
meta.size += nr;
// update cached variables
fpre = fpres[page];
npre = page + 1 < used && fpres[page + 1] < meta.size ? fpres[page + 1] : meta.size;
}