source: trip-planner-front/node_modules/smart-buffer/build/smartbuffer.js@ eed0bf8

Last change on this file since eed0bf8 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 43.5 KB
Line 
1"use strict";
2Object.defineProperty(exports, "__esModule", { value: true });
3const utils_1 = require("./utils");
4// The default Buffer size if one is not provided.
5const DEFAULT_SMARTBUFFER_SIZE = 4096;
6// The default string encoding to use for reading/writing strings.
7const DEFAULT_SMARTBUFFER_ENCODING = 'utf8';
8class SmartBuffer {
9 /**
10 * Creates a new SmartBuffer instance.
11 *
12 * @param options { SmartBufferOptions } The SmartBufferOptions to apply to this instance.
13 */
14 constructor(options) {
15 this.length = 0;
16 this._encoding = DEFAULT_SMARTBUFFER_ENCODING;
17 this._writeOffset = 0;
18 this._readOffset = 0;
19 if (SmartBuffer.isSmartBufferOptions(options)) {
20 // Checks for encoding
21 if (options.encoding) {
22 utils_1.checkEncoding(options.encoding);
23 this._encoding = options.encoding;
24 }
25 // Checks for initial size length
26 if (options.size) {
27 if (utils_1.isFiniteInteger(options.size) && options.size > 0) {
28 this._buff = Buffer.allocUnsafe(options.size);
29 }
30 else {
31 throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE);
32 }
33 // Check for initial Buffer
34 }
35 else if (options.buff) {
36 if (Buffer.isBuffer(options.buff)) {
37 this._buff = options.buff;
38 this.length = options.buff.length;
39 }
40 else {
41 throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER);
42 }
43 }
44 else {
45 this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
46 }
47 }
48 else {
49 // If something was passed but it's not a SmartBufferOptions object
50 if (typeof options !== 'undefined') {
51 throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT);
52 }
53 // Otherwise default to sane options
54 this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
55 }
56 }
57 /**
58 * Creates a new SmartBuffer instance with the provided internal Buffer size and optional encoding.
59 *
60 * @param size { Number } The size of the internal Buffer.
61 * @param encoding { String } The BufferEncoding to use for strings.
62 *
63 * @return { SmartBuffer }
64 */
65 static fromSize(size, encoding) {
66 return new this({
67 size: size,
68 encoding: encoding
69 });
70 }
71 /**
72 * Creates a new SmartBuffer instance with the provided Buffer and optional encoding.
73 *
74 * @param buffer { Buffer } The Buffer to use as the internal Buffer value.
75 * @param encoding { String } The BufferEncoding to use for strings.
76 *
77 * @return { SmartBuffer }
78 */
79 static fromBuffer(buff, encoding) {
80 return new this({
81 buff: buff,
82 encoding: encoding
83 });
84 }
85 /**
86 * Creates a new SmartBuffer instance with the provided SmartBufferOptions options.
87 *
88 * @param options { SmartBufferOptions } The options to use when creating the SmartBuffer instance.
89 */
90 static fromOptions(options) {
91 return new this(options);
92 }
93 /**
94 * Type checking function that determines if an object is a SmartBufferOptions object.
95 */
96 static isSmartBufferOptions(options) {
97 const castOptions = options;
98 return (castOptions &&
99 (castOptions.encoding !== undefined || castOptions.size !== undefined || castOptions.buff !== undefined));
100 }
101 // Signed integers
102 /**
103 * Reads an Int8 value from the current read position or an optionally provided offset.
104 *
105 * @param offset { Number } The offset to read data from (optional)
106 * @return { Number }
107 */
108 readInt8(offset) {
109 return this._readNumberValue(Buffer.prototype.readInt8, 1, offset);
110 }
111 /**
112 * Reads an Int16BE value from the current read position or an optionally provided offset.
113 *
114 * @param offset { Number } The offset to read data from (optional)
115 * @return { Number }
116 */
117 readInt16BE(offset) {
118 return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset);
119 }
120 /**
121 * Reads an Int16LE value from the current read position or an optionally provided offset.
122 *
123 * @param offset { Number } The offset to read data from (optional)
124 * @return { Number }
125 */
126 readInt16LE(offset) {
127 return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset);
128 }
129 /**
130 * Reads an Int32BE value from the current read position or an optionally provided offset.
131 *
132 * @param offset { Number } The offset to read data from (optional)
133 * @return { Number }
134 */
135 readInt32BE(offset) {
136 return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset);
137 }
138 /**
139 * Reads an Int32LE value from the current read position or an optionally provided offset.
140 *
141 * @param offset { Number } The offset to read data from (optional)
142 * @return { Number }
143 */
144 readInt32LE(offset) {
145 return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset);
146 }
147 /**
148 * Reads a BigInt64BE value from the current read position or an optionally provided offset.
149 *
150 * @param offset { Number } The offset to read data from (optional)
151 * @return { BigInt }
152 */
153 readBigInt64BE(offset) {
154 utils_1.bigIntAndBufferInt64Check('readBigInt64BE');
155 return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset);
156 }
157 /**
158 * Reads a BigInt64LE value from the current read position or an optionally provided offset.
159 *
160 * @param offset { Number } The offset to read data from (optional)
161 * @return { BigInt }
162 */
163 readBigInt64LE(offset) {
164 utils_1.bigIntAndBufferInt64Check('readBigInt64LE');
165 return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset);
166 }
167 /**
168 * Writes an Int8 value to the current write position (or at optional offset).
169 *
170 * @param value { Number } The value to write.
171 * @param offset { Number } The offset to write the value at.
172 *
173 * @return this
174 */
175 writeInt8(value, offset) {
176 this._writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
177 return this;
178 }
179 /**
180 * Inserts an Int8 value at the given offset value.
181 *
182 * @param value { Number } The value to insert.
183 * @param offset { Number } The offset to insert the value at.
184 *
185 * @return this
186 */
187 insertInt8(value, offset) {
188 return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
189 }
190 /**
191 * Writes an Int16BE value to the current write position (or at optional offset).
192 *
193 * @param value { Number } The value to write.
194 * @param offset { Number } The offset to write the value at.
195 *
196 * @return this
197 */
198 writeInt16BE(value, offset) {
199 return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
200 }
201 /**
202 * Inserts an Int16BE value at the given offset value.
203 *
204 * @param value { Number } The value to insert.
205 * @param offset { Number } The offset to insert the value at.
206 *
207 * @return this
208 */
209 insertInt16BE(value, offset) {
210 return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
211 }
212 /**
213 * Writes an Int16LE value to the current write position (or at optional offset).
214 *
215 * @param value { Number } The value to write.
216 * @param offset { Number } The offset to write the value at.
217 *
218 * @return this
219 */
220 writeInt16LE(value, offset) {
221 return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
222 }
223 /**
224 * Inserts an Int16LE value at the given offset value.
225 *
226 * @param value { Number } The value to insert.
227 * @param offset { Number } The offset to insert the value at.
228 *
229 * @return this
230 */
231 insertInt16LE(value, offset) {
232 return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
233 }
234 /**
235 * Writes an Int32BE value to the current write position (or at optional offset).
236 *
237 * @param value { Number } The value to write.
238 * @param offset { Number } The offset to write the value at.
239 *
240 * @return this
241 */
242 writeInt32BE(value, offset) {
243 return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
244 }
245 /**
246 * Inserts an Int32BE value at the given offset value.
247 *
248 * @param value { Number } The value to insert.
249 * @param offset { Number } The offset to insert the value at.
250 *
251 * @return this
252 */
253 insertInt32BE(value, offset) {
254 return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
255 }
256 /**
257 * Writes an Int32LE value to the current write position (or at optional offset).
258 *
259 * @param value { Number } The value to write.
260 * @param offset { Number } The offset to write the value at.
261 *
262 * @return this
263 */
264 writeInt32LE(value, offset) {
265 return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
266 }
267 /**
268 * Inserts an Int32LE value at the given offset value.
269 *
270 * @param value { Number } The value to insert.
271 * @param offset { Number } The offset to insert the value at.
272 *
273 * @return this
274 */
275 insertInt32LE(value, offset) {
276 return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
277 }
278 /**
279 * Writes a BigInt64BE value to the current write position (or at optional offset).
280 *
281 * @param value { BigInt } The value to write.
282 * @param offset { Number } The offset to write the value at.
283 *
284 * @return this
285 */
286 writeBigInt64BE(value, offset) {
287 utils_1.bigIntAndBufferInt64Check('writeBigInt64BE');
288 return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
289 }
290 /**
291 * Inserts a BigInt64BE value at the given offset value.
292 *
293 * @param value { BigInt } The value to insert.
294 * @param offset { Number } The offset to insert the value at.
295 *
296 * @return this
297 */
298 insertBigInt64BE(value, offset) {
299 utils_1.bigIntAndBufferInt64Check('writeBigInt64BE');
300 return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
301 }
302 /**
303 * Writes a BigInt64LE value to the current write position (or at optional offset).
304 *
305 * @param value { BigInt } The value to write.
306 * @param offset { Number } The offset to write the value at.
307 *
308 * @return this
309 */
310 writeBigInt64LE(value, offset) {
311 utils_1.bigIntAndBufferInt64Check('writeBigInt64LE');
312 return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
313 }
314 /**
315 * Inserts a Int64LE value at the given offset value.
316 *
317 * @param value { BigInt } The value to insert.
318 * @param offset { Number } The offset to insert the value at.
319 *
320 * @return this
321 */
322 insertBigInt64LE(value, offset) {
323 utils_1.bigIntAndBufferInt64Check('writeBigInt64LE');
324 return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
325 }
326 // Unsigned Integers
327 /**
328 * Reads an UInt8 value from the current read position or an optionally provided offset.
329 *
330 * @param offset { Number } The offset to read data from (optional)
331 * @return { Number }
332 */
333 readUInt8(offset) {
334 return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset);
335 }
336 /**
337 * Reads an UInt16BE value from the current read position or an optionally provided offset.
338 *
339 * @param offset { Number } The offset to read data from (optional)
340 * @return { Number }
341 */
342 readUInt16BE(offset) {
343 return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset);
344 }
345 /**
346 * Reads an UInt16LE value from the current read position or an optionally provided offset.
347 *
348 * @param offset { Number } The offset to read data from (optional)
349 * @return { Number }
350 */
351 readUInt16LE(offset) {
352 return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset);
353 }
354 /**
355 * Reads an UInt32BE value from the current read position or an optionally provided offset.
356 *
357 * @param offset { Number } The offset to read data from (optional)
358 * @return { Number }
359 */
360 readUInt32BE(offset) {
361 return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset);
362 }
363 /**
364 * Reads an UInt32LE value from the current read position or an optionally provided offset.
365 *
366 * @param offset { Number } The offset to read data from (optional)
367 * @return { Number }
368 */
369 readUInt32LE(offset) {
370 return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset);
371 }
372 /**
373 * Reads a BigUInt64BE value from the current read position or an optionally provided offset.
374 *
375 * @param offset { Number } The offset to read data from (optional)
376 * @return { BigInt }
377 */
378 readBigUInt64BE(offset) {
379 utils_1.bigIntAndBufferInt64Check('readBigUInt64BE');
380 return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset);
381 }
382 /**
383 * Reads a BigUInt64LE value from the current read position or an optionally provided offset.
384 *
385 * @param offset { Number } The offset to read data from (optional)
386 * @return { BigInt }
387 */
388 readBigUInt64LE(offset) {
389 utils_1.bigIntAndBufferInt64Check('readBigUInt64LE');
390 return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset);
391 }
392 /**
393 * Writes an UInt8 value to the current write position (or at optional offset).
394 *
395 * @param value { Number } The value to write.
396 * @param offset { Number } The offset to write the value at.
397 *
398 * @return this
399 */
400 writeUInt8(value, offset) {
401 return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
402 }
403 /**
404 * Inserts an UInt8 value at the given offset value.
405 *
406 * @param value { Number } The value to insert.
407 * @param offset { Number } The offset to insert the value at.
408 *
409 * @return this
410 */
411 insertUInt8(value, offset) {
412 return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
413 }
414 /**
415 * Writes an UInt16BE value to the current write position (or at optional offset).
416 *
417 * @param value { Number } The value to write.
418 * @param offset { Number } The offset to write the value at.
419 *
420 * @return this
421 */
422 writeUInt16BE(value, offset) {
423 return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
424 }
425 /**
426 * Inserts an UInt16BE value at the given offset value.
427 *
428 * @param value { Number } The value to insert.
429 * @param offset { Number } The offset to insert the value at.
430 *
431 * @return this
432 */
433 insertUInt16BE(value, offset) {
434 return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
435 }
436 /**
437 * Writes an UInt16LE value to the current write position (or at optional offset).
438 *
439 * @param value { Number } The value to write.
440 * @param offset { Number } The offset to write the value at.
441 *
442 * @return this
443 */
444 writeUInt16LE(value, offset) {
445 return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
446 }
447 /**
448 * Inserts an UInt16LE value at the given offset value.
449 *
450 * @param value { Number } The value to insert.
451 * @param offset { Number } The offset to insert the value at.
452 *
453 * @return this
454 */
455 insertUInt16LE(value, offset) {
456 return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
457 }
458 /**
459 * Writes an UInt32BE value to the current write position (or at optional offset).
460 *
461 * @param value { Number } The value to write.
462 * @param offset { Number } The offset to write the value at.
463 *
464 * @return this
465 */
466 writeUInt32BE(value, offset) {
467 return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
468 }
469 /**
470 * Inserts an UInt32BE value at the given offset value.
471 *
472 * @param value { Number } The value to insert.
473 * @param offset { Number } The offset to insert the value at.
474 *
475 * @return this
476 */
477 insertUInt32BE(value, offset) {
478 return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
479 }
480 /**
481 * Writes an UInt32LE value to the current write position (or at optional offset).
482 *
483 * @param value { Number } The value to write.
484 * @param offset { Number } The offset to write the value at.
485 *
486 * @return this
487 */
488 writeUInt32LE(value, offset) {
489 return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
490 }
491 /**
492 * Inserts an UInt32LE value at the given offset value.
493 *
494 * @param value { Number } The value to insert.
495 * @param offset { Number } The offset to insert the value at.
496 *
497 * @return this
498 */
499 insertUInt32LE(value, offset) {
500 return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
501 }
502 /**
503 * Writes a BigUInt64BE value to the current write position (or at optional offset).
504 *
505 * @param value { Number } The value to write.
506 * @param offset { Number } The offset to write the value at.
507 *
508 * @return this
509 */
510 writeBigUInt64BE(value, offset) {
511 utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE');
512 return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
513 }
514 /**
515 * Inserts a BigUInt64BE value at the given offset value.
516 *
517 * @param value { Number } The value to insert.
518 * @param offset { Number } The offset to insert the value at.
519 *
520 * @return this
521 */
522 insertBigUInt64BE(value, offset) {
523 utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE');
524 return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
525 }
526 /**
527 * Writes a BigUInt64LE value to the current write position (or at optional offset).
528 *
529 * @param value { Number } The value to write.
530 * @param offset { Number } The offset to write the value at.
531 *
532 * @return this
533 */
534 writeBigUInt64LE(value, offset) {
535 utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE');
536 return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
537 }
538 /**
539 * Inserts a BigUInt64LE value at the given offset value.
540 *
541 * @param value { Number } The value to insert.
542 * @param offset { Number } The offset to insert the value at.
543 *
544 * @return this
545 */
546 insertBigUInt64LE(value, offset) {
547 utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE');
548 return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
549 }
550 // Floating Point
551 /**
552 * Reads an FloatBE value from the current read position or an optionally provided offset.
553 *
554 * @param offset { Number } The offset to read data from (optional)
555 * @return { Number }
556 */
557 readFloatBE(offset) {
558 return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset);
559 }
560 /**
561 * Reads an FloatLE value from the current read position or an optionally provided offset.
562 *
563 * @param offset { Number } The offset to read data from (optional)
564 * @return { Number }
565 */
566 readFloatLE(offset) {
567 return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset);
568 }
569 /**
570 * Writes a FloatBE value to the current write position (or at optional offset).
571 *
572 * @param value { Number } The value to write.
573 * @param offset { Number } The offset to write the value at.
574 *
575 * @return this
576 */
577 writeFloatBE(value, offset) {
578 return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
579 }
580 /**
581 * Inserts a FloatBE value at the given offset value.
582 *
583 * @param value { Number } The value to insert.
584 * @param offset { Number } The offset to insert the value at.
585 *
586 * @return this
587 */
588 insertFloatBE(value, offset) {
589 return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
590 }
591 /**
592 * Writes a FloatLE value to the current write position (or at optional offset).
593 *
594 * @param value { Number } The value to write.
595 * @param offset { Number } The offset to write the value at.
596 *
597 * @return this
598 */
599 writeFloatLE(value, offset) {
600 return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
601 }
602 /**
603 * Inserts a FloatLE value at the given offset value.
604 *
605 * @param value { Number } The value to insert.
606 * @param offset { Number } The offset to insert the value at.
607 *
608 * @return this
609 */
610 insertFloatLE(value, offset) {
611 return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
612 }
613 // Double Floating Point
614 /**
615 * Reads an DoublEBE value from the current read position or an optionally provided offset.
616 *
617 * @param offset { Number } The offset to read data from (optional)
618 * @return { Number }
619 */
620 readDoubleBE(offset) {
621 return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset);
622 }
623 /**
624 * Reads an DoubleLE value from the current read position or an optionally provided offset.
625 *
626 * @param offset { Number } The offset to read data from (optional)
627 * @return { Number }
628 */
629 readDoubleLE(offset) {
630 return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset);
631 }
632 /**
633 * Writes a DoubleBE value to the current write position (or at optional offset).
634 *
635 * @param value { Number } The value to write.
636 * @param offset { Number } The offset to write the value at.
637 *
638 * @return this
639 */
640 writeDoubleBE(value, offset) {
641 return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
642 }
643 /**
644 * Inserts a DoubleBE value at the given offset value.
645 *
646 * @param value { Number } The value to insert.
647 * @param offset { Number } The offset to insert the value at.
648 *
649 * @return this
650 */
651 insertDoubleBE(value, offset) {
652 return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
653 }
654 /**
655 * Writes a DoubleLE value to the current write position (or at optional offset).
656 *
657 * @param value { Number } The value to write.
658 * @param offset { Number } The offset to write the value at.
659 *
660 * @return this
661 */
662 writeDoubleLE(value, offset) {
663 return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
664 }
665 /**
666 * Inserts a DoubleLE value at the given offset value.
667 *
668 * @param value { Number } The value to insert.
669 * @param offset { Number } The offset to insert the value at.
670 *
671 * @return this
672 */
673 insertDoubleLE(value, offset) {
674 return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
675 }
676 // Strings
677 /**
678 * Reads a String from the current read position.
679 *
680 * @param arg1 { Number | String } The number of bytes to read as a String, or the BufferEncoding to use for
681 * the string (Defaults to instance level encoding).
682 * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding).
683 *
684 * @return { String }
685 */
686 readString(arg1, encoding) {
687 let lengthVal;
688 // Length provided
689 if (typeof arg1 === 'number') {
690 utils_1.checkLengthValue(arg1);
691 lengthVal = Math.min(arg1, this.length - this._readOffset);
692 }
693 else {
694 encoding = arg1;
695 lengthVal = this.length - this._readOffset;
696 }
697 // Check encoding
698 if (typeof encoding !== 'undefined') {
699 utils_1.checkEncoding(encoding);
700 }
701 const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding);
702 this._readOffset += lengthVal;
703 return value;
704 }
705 /**
706 * Inserts a String
707 *
708 * @param value { String } The String value to insert.
709 * @param offset { Number } The offset to insert the string at.
710 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
711 *
712 * @return this
713 */
714 insertString(value, offset, encoding) {
715 utils_1.checkOffsetValue(offset);
716 return this._handleString(value, true, offset, encoding);
717 }
718 /**
719 * Writes a String
720 *
721 * @param value { String } The String value to write.
722 * @param arg2 { Number | String } The offset to write the string at, or the BufferEncoding to use.
723 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
724 *
725 * @return this
726 */
727 writeString(value, arg2, encoding) {
728 return this._handleString(value, false, arg2, encoding);
729 }
730 /**
731 * Reads a null-terminated String from the current read position.
732 *
733 * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding).
734 *
735 * @return { String }
736 */
737 readStringNT(encoding) {
738 if (typeof encoding !== 'undefined') {
739 utils_1.checkEncoding(encoding);
740 }
741 // Set null character position to the end SmartBuffer instance.
742 let nullPos = this.length;
743 // Find next null character (if one is not found, default from above is used)
744 for (let i = this._readOffset; i < this.length; i++) {
745 if (this._buff[i] === 0x00) {
746 nullPos = i;
747 break;
748 }
749 }
750 // Read string value
751 const value = this._buff.slice(this._readOffset, nullPos);
752 // Increment internal Buffer read offset
753 this._readOffset = nullPos + 1;
754 return value.toString(encoding || this._encoding);
755 }
756 /**
757 * Inserts a null-terminated String.
758 *
759 * @param value { String } The String value to write.
760 * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use.
761 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
762 *
763 * @return this
764 */
765 insertStringNT(value, offset, encoding) {
766 utils_1.checkOffsetValue(offset);
767 // Write Values
768 this.insertString(value, offset, encoding);
769 this.insertUInt8(0x00, offset + value.length);
770 return this;
771 }
772 /**
773 * Writes a null-terminated String.
774 *
775 * @param value { String } The String value to write.
776 * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use.
777 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
778 *
779 * @return this
780 */
781 writeStringNT(value, arg2, encoding) {
782 // Write Values
783 this.writeString(value, arg2, encoding);
784 this.writeUInt8(0x00, typeof arg2 === 'number' ? arg2 + value.length : this.writeOffset);
785 return this;
786 }
787 // Buffers
788 /**
789 * Reads a Buffer from the internal read position.
790 *
791 * @param length { Number } The length of data to read as a Buffer.
792 *
793 * @return { Buffer }
794 */
795 readBuffer(length) {
796 if (typeof length !== 'undefined') {
797 utils_1.checkLengthValue(length);
798 }
799 const lengthVal = typeof length === 'number' ? length : this.length;
800 const endPoint = Math.min(this.length, this._readOffset + lengthVal);
801 // Read buffer value
802 const value = this._buff.slice(this._readOffset, endPoint);
803 // Increment internal Buffer read offset
804 this._readOffset = endPoint;
805 return value;
806 }
807 /**
808 * Writes a Buffer to the current write position.
809 *
810 * @param value { Buffer } The Buffer to write.
811 * @param offset { Number } The offset to write the Buffer to.
812 *
813 * @return this
814 */
815 insertBuffer(value, offset) {
816 utils_1.checkOffsetValue(offset);
817 return this._handleBuffer(value, true, offset);
818 }
819 /**
820 * Writes a Buffer to the current write position.
821 *
822 * @param value { Buffer } The Buffer to write.
823 * @param offset { Number } The offset to write the Buffer to.
824 *
825 * @return this
826 */
827 writeBuffer(value, offset) {
828 return this._handleBuffer(value, false, offset);
829 }
830 /**
831 * Reads a null-terminated Buffer from the current read poisiton.
832 *
833 * @return { Buffer }
834 */
835 readBufferNT() {
836 // Set null character position to the end SmartBuffer instance.
837 let nullPos = this.length;
838 // Find next null character (if one is not found, default from above is used)
839 for (let i = this._readOffset; i < this.length; i++) {
840 if (this._buff[i] === 0x00) {
841 nullPos = i;
842 break;
843 }
844 }
845 // Read value
846 const value = this._buff.slice(this._readOffset, nullPos);
847 // Increment internal Buffer read offset
848 this._readOffset = nullPos + 1;
849 return value;
850 }
851 /**
852 * Inserts a null-terminated Buffer.
853 *
854 * @param value { Buffer } The Buffer to write.
855 * @param offset { Number } The offset to write the Buffer to.
856 *
857 * @return this
858 */
859 insertBufferNT(value, offset) {
860 utils_1.checkOffsetValue(offset);
861 // Write Values
862 this.insertBuffer(value, offset);
863 this.insertUInt8(0x00, offset + value.length);
864 return this;
865 }
866 /**
867 * Writes a null-terminated Buffer.
868 *
869 * @param value { Buffer } The Buffer to write.
870 * @param offset { Number } The offset to write the Buffer to.
871 *
872 * @return this
873 */
874 writeBufferNT(value, offset) {
875 // Checks for valid numberic value;
876 if (typeof offset !== 'undefined') {
877 utils_1.checkOffsetValue(offset);
878 }
879 // Write Values
880 this.writeBuffer(value, offset);
881 this.writeUInt8(0x00, typeof offset === 'number' ? offset + value.length : this._writeOffset);
882 return this;
883 }
884 /**
885 * Clears the SmartBuffer instance to its original empty state.
886 */
887 clear() {
888 this._writeOffset = 0;
889 this._readOffset = 0;
890 this.length = 0;
891 return this;
892 }
893 /**
894 * Gets the remaining data left to be read from the SmartBuffer instance.
895 *
896 * @return { Number }
897 */
898 remaining() {
899 return this.length - this._readOffset;
900 }
901 /**
902 * Gets the current read offset value of the SmartBuffer instance.
903 *
904 * @return { Number }
905 */
906 get readOffset() {
907 return this._readOffset;
908 }
909 /**
910 * Sets the read offset value of the SmartBuffer instance.
911 *
912 * @param offset { Number } - The offset value to set.
913 */
914 set readOffset(offset) {
915 utils_1.checkOffsetValue(offset);
916 // Check for bounds.
917 utils_1.checkTargetOffset(offset, this);
918 this._readOffset = offset;
919 }
920 /**
921 * Gets the current write offset value of the SmartBuffer instance.
922 *
923 * @return { Number }
924 */
925 get writeOffset() {
926 return this._writeOffset;
927 }
928 /**
929 * Sets the write offset value of the SmartBuffer instance.
930 *
931 * @param offset { Number } - The offset value to set.
932 */
933 set writeOffset(offset) {
934 utils_1.checkOffsetValue(offset);
935 // Check for bounds.
936 utils_1.checkTargetOffset(offset, this);
937 this._writeOffset = offset;
938 }
939 /**
940 * Gets the currently set string encoding of the SmartBuffer instance.
941 *
942 * @return { BufferEncoding } The string Buffer encoding currently set.
943 */
944 get encoding() {
945 return this._encoding;
946 }
947 /**
948 * Sets the string encoding of the SmartBuffer instance.
949 *
950 * @param encoding { BufferEncoding } The string Buffer encoding to set.
951 */
952 set encoding(encoding) {
953 utils_1.checkEncoding(encoding);
954 this._encoding = encoding;
955 }
956 /**
957 * Gets the underlying internal Buffer. (This includes unmanaged data in the Buffer)
958 *
959 * @return { Buffer } The Buffer value.
960 */
961 get internalBuffer() {
962 return this._buff;
963 }
964 /**
965 * Gets the value of the internal managed Buffer (Includes managed data only)
966 *
967 * @param { Buffer }
968 */
969 toBuffer() {
970 return this._buff.slice(0, this.length);
971 }
972 /**
973 * Gets the String value of the internal managed Buffer
974 *
975 * @param encoding { String } The BufferEncoding to display the Buffer as (defaults to instance level encoding).
976 */
977 toString(encoding) {
978 const encodingVal = typeof encoding === 'string' ? encoding : this._encoding;
979 // Check for invalid encoding.
980 utils_1.checkEncoding(encodingVal);
981 return this._buff.toString(encodingVal, 0, this.length);
982 }
983 /**
984 * Destroys the SmartBuffer instance.
985 */
986 destroy() {
987 this.clear();
988 return this;
989 }
990 /**
991 * Handles inserting and writing strings.
992 *
993 * @param value { String } The String value to insert.
994 * @param isInsert { Boolean } True if inserting a string, false if writing.
995 * @param arg2 { Number | String } The offset to insert the string at, or the BufferEncoding to use.
996 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).
997 */
998 _handleString(value, isInsert, arg3, encoding) {
999 let offsetVal = this._writeOffset;
1000 let encodingVal = this._encoding;
1001 // Check for offset
1002 if (typeof arg3 === 'number') {
1003 offsetVal = arg3;
1004 // Check for encoding
1005 }
1006 else if (typeof arg3 === 'string') {
1007 utils_1.checkEncoding(arg3);
1008 encodingVal = arg3;
1009 }
1010 // Check for encoding (third param)
1011 if (typeof encoding === 'string') {
1012 utils_1.checkEncoding(encoding);
1013 encodingVal = encoding;
1014 }
1015 // Calculate bytelength of string.
1016 const byteLength = Buffer.byteLength(value, encodingVal);
1017 // Ensure there is enough internal Buffer capacity.
1018 if (isInsert) {
1019 this.ensureInsertable(byteLength, offsetVal);
1020 }
1021 else {
1022 this._ensureWriteable(byteLength, offsetVal);
1023 }
1024 // Write value
1025 this._buff.write(value, offsetVal, byteLength, encodingVal);
1026 // Increment internal Buffer write offset;
1027 if (isInsert) {
1028 this._writeOffset += byteLength;
1029 }
1030 else {
1031 // If an offset was given, check to see if we wrote beyond the current writeOffset.
1032 if (typeof arg3 === 'number') {
1033 this._writeOffset = Math.max(this._writeOffset, offsetVal + byteLength);
1034 }
1035 else {
1036 // If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
1037 this._writeOffset += byteLength;
1038 }
1039 }
1040 return this;
1041 }
1042 /**
1043 * Handles writing or insert of a Buffer.
1044 *
1045 * @param value { Buffer } The Buffer to write.
1046 * @param offset { Number } The offset to write the Buffer to.
1047 */
1048 _handleBuffer(value, isInsert, offset) {
1049 const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
1050 // Ensure there is enough internal Buffer capacity.
1051 if (isInsert) {
1052 this.ensureInsertable(value.length, offsetVal);
1053 }
1054 else {
1055 this._ensureWriteable(value.length, offsetVal);
1056 }
1057 // Write buffer value
1058 value.copy(this._buff, offsetVal);
1059 // Increment internal Buffer write offset;
1060 if (isInsert) {
1061 this._writeOffset += value.length;
1062 }
1063 else {
1064 // If an offset was given, check to see if we wrote beyond the current writeOffset.
1065 if (typeof offset === 'number') {
1066 this._writeOffset = Math.max(this._writeOffset, offsetVal + value.length);
1067 }
1068 else {
1069 // If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
1070 this._writeOffset += value.length;
1071 }
1072 }
1073 return this;
1074 }
1075 /**
1076 * Ensures that the internal Buffer is large enough to read data.
1077 *
1078 * @param length { Number } The length of the data that needs to be read.
1079 * @param offset { Number } The offset of the data that needs to be read.
1080 */
1081 ensureReadable(length, offset) {
1082 // Offset value defaults to managed read offset.
1083 let offsetVal = this._readOffset;
1084 // If an offset was provided, use it.
1085 if (typeof offset !== 'undefined') {
1086 // Checks for valid numberic value;
1087 utils_1.checkOffsetValue(offset);
1088 // Overide with custom offset.
1089 offsetVal = offset;
1090 }
1091 // Checks if offset is below zero, or the offset+length offset is beyond the total length of the managed data.
1092 if (offsetVal < 0 || offsetVal + length > this.length) {
1093 throw new Error(utils_1.ERRORS.INVALID_READ_BEYOND_BOUNDS);
1094 }
1095 }
1096 /**
1097 * Ensures that the internal Buffer is large enough to insert data.
1098 *
1099 * @param dataLength { Number } The length of the data that needs to be written.
1100 * @param offset { Number } The offset of the data to be written.
1101 */
1102 ensureInsertable(dataLength, offset) {
1103 // Checks for valid numberic value;
1104 utils_1.checkOffsetValue(offset);
1105 // Ensure there is enough internal Buffer capacity.
1106 this._ensureCapacity(this.length + dataLength);
1107 // If an offset was provided and its not the very end of the buffer, copy data into appropriate location in regards to the offset.
1108 if (offset < this.length) {
1109 this._buff.copy(this._buff, offset + dataLength, offset, this._buff.length);
1110 }
1111 // Adjust tracked smart buffer length
1112 if (offset + dataLength > this.length) {
1113 this.length = offset + dataLength;
1114 }
1115 else {
1116 this.length += dataLength;
1117 }
1118 }
1119 /**
1120 * Ensures that the internal Buffer is large enough to write data.
1121 *
1122 * @param dataLength { Number } The length of the data that needs to be written.
1123 * @param offset { Number } The offset of the data to be written (defaults to writeOffset).
1124 */
1125 _ensureWriteable(dataLength, offset) {
1126 const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
1127 // Ensure enough capacity to write data.
1128 this._ensureCapacity(offsetVal + dataLength);
1129 // Adjust SmartBuffer length (if offset + length is larger than managed length, adjust length)
1130 if (offsetVal + dataLength > this.length) {
1131 this.length = offsetVal + dataLength;
1132 }
1133 }
1134 /**
1135 * Ensures that the internal Buffer is large enough to write at least the given amount of data.
1136 *
1137 * @param minLength { Number } The minimum length of the data needs to be written.
1138 */
1139 _ensureCapacity(minLength) {
1140 const oldLength = this._buff.length;
1141 if (minLength > oldLength) {
1142 let data = this._buff;
1143 let newLength = (oldLength * 3) / 2 + 1;
1144 if (newLength < minLength) {
1145 newLength = minLength;
1146 }
1147 this._buff = Buffer.allocUnsafe(newLength);
1148 data.copy(this._buff, 0, 0, oldLength);
1149 }
1150 }
1151 /**
1152 * Reads a numeric number value using the provided function.
1153 *
1154 * @typeparam T { number | bigint } The type of the value to be read
1155 *
1156 * @param func { Function(offset: number) => number } The function to read data on the internal Buffer with.
1157 * @param byteSize { Number } The number of bytes read.
1158 * @param offset { Number } The offset to read from (optional). When this is not provided, the managed readOffset is used instead.
1159 *
1160 * @returns { T } the number value
1161 */
1162 _readNumberValue(func, byteSize, offset) {
1163 this.ensureReadable(byteSize, offset);
1164 // Call Buffer.readXXXX();
1165 const value = func.call(this._buff, typeof offset === 'number' ? offset : this._readOffset);
1166 // Adjust internal read offset if an optional read offset was not provided.
1167 if (typeof offset === 'undefined') {
1168 this._readOffset += byteSize;
1169 }
1170 return value;
1171 }
1172 /**
1173 * Inserts a numeric number value based on the given offset and value.
1174 *
1175 * @typeparam T { number | bigint } The type of the value to be written
1176 *
1177 * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with.
1178 * @param byteSize { Number } The number of bytes written.
1179 * @param value { T } The number value to write.
1180 * @param offset { Number } the offset to write the number at (REQUIRED).
1181 *
1182 * @returns SmartBuffer this buffer
1183 */
1184 _insertNumberValue(func, byteSize, value, offset) {
1185 // Check for invalid offset values.
1186 utils_1.checkOffsetValue(offset);
1187 // Ensure there is enough internal Buffer capacity. (raw offset is passed)
1188 this.ensureInsertable(byteSize, offset);
1189 // Call buffer.writeXXXX();
1190 func.call(this._buff, value, offset);
1191 // Adjusts internally managed write offset.
1192 this._writeOffset += byteSize;
1193 return this;
1194 }
1195 /**
1196 * Writes a numeric number value based on the given offset and value.
1197 *
1198 * @typeparam T { number | bigint } The type of the value to be written
1199 *
1200 * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with.
1201 * @param byteSize { Number } The number of bytes written.
1202 * @param value { T } The number value to write.
1203 * @param offset { Number } the offset to write the number at (REQUIRED).
1204 *
1205 * @returns SmartBuffer this buffer
1206 */
1207 _writeNumberValue(func, byteSize, value, offset) {
1208 // If an offset was provided, validate it.
1209 if (typeof offset === 'number') {
1210 // Check if we're writing beyond the bounds of the managed data.
1211 if (offset < 0) {
1212 throw new Error(utils_1.ERRORS.INVALID_WRITE_BEYOND_BOUNDS);
1213 }
1214 utils_1.checkOffsetValue(offset);
1215 }
1216 // Default to writeOffset if no offset value was given.
1217 const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;
1218 // Ensure there is enough internal Buffer capacity. (raw offset is passed)
1219 this._ensureWriteable(byteSize, offsetVal);
1220 func.call(this._buff, value, offsetVal);
1221 // If an offset was given, check to see if we wrote beyond the current writeOffset.
1222 if (typeof offset === 'number') {
1223 this._writeOffset = Math.max(this._writeOffset, offsetVal + byteSize);
1224 }
1225 else {
1226 // If no numeric offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.
1227 this._writeOffset += byteSize;
1228 }
1229 return this;
1230 }
1231}
1232exports.SmartBuffer = SmartBuffer;
1233//# sourceMappingURL=smartbuffer.js.map
Note: See TracBrowser for help on using the repository browser.