Code coverage report for lib/internal/smalloc.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
 
946
946
946
946
946
 
946
946
946
946
 
 
 
946
 
 
 
946
 
 
 
 
 
946
58
 
58
17
 
58
22
22
36
3
 
 
55
1
54
 
54
 
54
1
 
53
2
51
2
 
 
49
 
 
 
946
4
1
3
 
3
1
2
1
 
1
 
 
 
946
14
 
14
 
14
1
13
1
 
12
 
 
 
946
8
5
 
3
 
 
 
 
(function () { 'use strict';
 
const smalloc = process.binding('smalloc');
const kMaxLength = smalloc.kMaxLength;
const kMinType = smalloc.kMinType;
const kMaxType = smalloc.kMaxType;
const util = require('util');
 
exports.alloc = alloc;
exports.copyOnto = copyOnto;
exports.dispose = dispose;
exports.hasExternalData = hasExternalData;
 
// don't allow kMaxLength to accidentally be overwritten. it's a lot less
// apparent when a primitive is accidentally changed.
Object.defineProperty(exports, 'kMaxLength', {
  enumerable: true, value: kMaxLength, writable: false
});
 
Object.defineProperty(exports, 'Types', {
  enumerable: true, value: Object.freeze(smalloc.types), writable: false
});
 
 
// usage: obj = alloc(n[, obj][, type]);
function alloc(n, obj, type) {
  n = n >>> 0;
 
  if (obj === undefined)
    obj = {};
 
  if (typeof obj === 'number') {
    type = obj >>> 0;
    obj = {};
  } else if (util.isPrimitive(obj)) {
    throw new TypeError('obj must be an Object');
  }
 
  if (Array.isArray(obj))
    throw new TypeError('obj cannot be an array');
  Iif (obj instanceof Buffer)
    throw new TypeError('obj cannot be a Buffer');
  Iif (smalloc.isTypedArray(obj))
    throw new TypeError('obj cannot be a typed array');
  if (smalloc.hasExternalData(obj))
    throw new TypeError('object already has external array data');
 
  if (type < kMinType || type > kMaxType)
    throw new TypeError('unknown external array type: ' + type);
  if (n > kMaxLength)
    throw new RangeError('Attempt to allocate array larger than maximum ' +
                         'size: 0x' + kMaxLength.toString(16) + ' elements');
 
  return smalloc.alloc(obj, n, type);
}
 
 
function dispose(obj) {
  if (util.isPrimitive(obj))
    throw new TypeError('obj must be an Object');
  Iif (obj instanceof Buffer)
    throw new TypeError('obj cannot be a Buffer');
  if (smalloc.isTypedArray(obj))
    throw new TypeError('obj cannot be a typed array');
  if (!smalloc.hasExternalData(obj))
    throw new TypeError('obj has no external array data');
 
  smalloc.dispose(obj);
}
 
 
function copyOnto(source, sourceStart, dest, destStart, copyLength) {
  Iif (util.isPrimitive(source))
    throw new TypeError('source must be an Object');
  Iif (util.isPrimitive(dest))
    throw new TypeError('dest must be an Object');
  if (!smalloc.hasExternalData(source))
    throw new TypeError('source has no external array data');
  if (!smalloc.hasExternalData(dest))
    throw new TypeError('dest has no external array data');
 
  return smalloc.copyOnto(source, sourceStart, dest, destStart, copyLength);
}
 
 
function hasExternalData(obj) {
  if (util.isPrimitive(obj))
    return false;
 
  return smalloc.hasExternalData(obj);
}
 
}());