1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-25 08:39:09 -05:00
denoland-deno/std/node/_stream/buffer_list.ts

184 lines
4.1 KiB
TypeScript
Raw Normal View History

// Copyright Node.js contributors. All rights reserved. MIT License.
import { Buffer } from "../buffer.ts";
type BufferListItem = {
data: Buffer | string | Uint8Array;
next: BufferListItem | null;
};
export default class BufferList {
head: BufferListItem | null = null;
tail: BufferListItem | null = null;
length: number;
constructor() {
this.head = null;
this.tail = null;
this.length = 0;
}
push(v: Buffer | string | Uint8Array) {
const entry = { data: v, next: null };
if (this.length > 0) {
(this.tail as BufferListItem).next = entry;
} else {
this.head = entry;
}
this.tail = entry;
++this.length;
}
unshift(v: Buffer | string | Uint8Array) {
const entry = { data: v, next: this.head };
if (this.length === 0) {
this.tail = entry;
}
this.head = entry;
++this.length;
}
shift() {
if (this.length === 0) {
return;
}
const ret = (this.head as BufferListItem).data;
if (this.length === 1) {
this.head = this.tail = null;
} else {
this.head = (this.head as BufferListItem).next;
}
--this.length;
return ret;
}
clear() {
this.head = this.tail = null;
this.length = 0;
}
join(s: string) {
if (this.length === 0) {
return "";
}
let p: BufferListItem | null = (this.head as BufferListItem);
let ret = "" + p.data;
p = p.next;
while (p) {
ret += s + p.data;
p = p.next;
}
return ret;
}
concat(n: number) {
if (this.length === 0) {
return Buffer.alloc(0);
}
const ret = Buffer.allocUnsafe(n >>> 0);
let p = this.head;
let i = 0;
while (p) {
ret.set(p.data as Buffer, i);
i += p.data.length;
p = p.next;
}
return ret;
}
// Consumes a specified amount of bytes or characters from the buffered data.
consume(n: number, hasStrings: boolean) {
const data = (this.head as BufferListItem).data;
if (n < data.length) {
// `slice` is the same for buffers and strings.
const slice = data.slice(0, n);
(this.head as BufferListItem).data = data.slice(n);
return slice;
}
if (n === data.length) {
// First chunk is a perfect match.
return this.shift();
}
// Result spans more than one buffer.
return hasStrings ? this._getString(n) : this._getBuffer(n);
}
first() {
return (this.head as BufferListItem).data;
}
*[Symbol.iterator]() {
for (let p = this.head; p; p = p.next) {
yield p.data;
}
}
// Consumes a specified amount of characters from the buffered data.
_getString(n: number) {
let ret = "";
let p: BufferListItem | null = (this.head as BufferListItem);
let c = 0;
p = p.next as BufferListItem;
do {
const str = p.data;
if (n > str.length) {
ret += str;
n -= str.length;
} else {
if (n === str.length) {
ret += str;
++c;
if (p.next) {
this.head = p.next;
} else {
this.head = this.tail = null;
}
} else {
ret += str.slice(0, n);
this.head = p;
p.data = str.slice(n);
}
break;
}
++c;
p = p.next;
} while (p);
this.length -= c;
return ret;
}
// Consumes a specified amount of bytes from the buffered data.
_getBuffer(n: number) {
const ret = Buffer.allocUnsafe(n);
const retLen = n;
let p: BufferListItem | null = (this.head as BufferListItem);
let c = 0;
p = p.next as BufferListItem;
do {
const buf = p.data as Buffer;
if (n > buf.length) {
ret.set(buf, retLen - n);
n -= buf.length;
} else {
if (n === buf.length) {
ret.set(buf, retLen - n);
++c;
if (p.next) {
this.head = p.next;
} else {
this.head = this.tail = null;
}
} else {
ret.set(new Uint8Array(buf.buffer, buf.byteOffset, n), retLen - n);
this.head = p;
p.data = buf.slice(n);
}
break;
}
++c;
p = p.next;
} while (p);
this.length -= c;
return ret;
}
}