function copy() {
binary.writeUInt32LE(OFFSET_BUFFER, 0, 0)
binary.writeUInt32LE(LENGTH_BUFFER, 0, 0)
var check = 1
, length
, offset
for(var x = 0; x < 4; ++x) {
if(command & check) {
OFFSET_BUFFER[3 - x] = delta[idx++]
}
check <<= 1
}
for(var x = 0; x < 3; ++x) {
if(command & check) {
LENGTH_BUFFER[3 - x] = delta[idx++]
}
check <<= 1
}
LENGTH_BUFFER[0] = 0
length = binary.readUInt32BE(LENGTH_BUFFER, 0) || 0x10000
offset = binary.readUInt32BE(OFFSET_BUFFER, 0)
binary.copy(target, output_buffer, out_idx, offset, offset + length)
out_idx += length
}
function write_string_no_pos(buffer, pos, string) {
if (Buffer.isBuffer(buffer)) {
buffer.write(string, pos);
} else {
var bufString = bops.from(string, 'utf8');
bops.copy(bufString, buffer, pos, 0, bufString.length);
}
}
encode: function(message) {
var keys = message.senderKey.split(':');
var ip = keys[0].split('.');
var toPack;
if(message.encrypted) {
toPack = [
msgpack.encode(parseInt(ip[0])),
msgpack.encode(parseInt(ip[1])),
msgpack.encode(parseInt(ip[2])),
msgpack.encode(parseInt(ip[3])),
msgpack.encode(parseInt(keys[1])),
msgpack.encode(parseInt(keys[2])),
msgpack.encode(true),
msgpack.encode(message.key),
msgpack.encode(message.executeTime),
msgpack.encode(message.millisecondsSinceMidnight),
msgpack.encode(message.topic),
msgpack.encode(message.partition),
msgpack.encode(message.type),
msgpack.encode(message.payload)
];
} else {
toPack = [
msgpack.encode(parseInt(ip[0])),
msgpack.encode(parseInt(ip[1])),
msgpack.encode(parseInt(ip[2])),
msgpack.encode(parseInt(ip[3])),
msgpack.encode(parseInt(keys[1])),
msgpack.encode(parseInt(keys[2])),
msgpack.encode(false),
msgpack.encode(parseInt(message.executeTime)),
msgpack.encode(parseInt(message.millisecondsSinceMidnight)),
msgpack.encode(message.topic),
msgpack.encode(message.partition),
msgpack.encode(message.type),
msgpack.encode(message.payload)
];
}
var buff = bops.join(toPack);
var newBuff = bops.create(buff.length + 2);
bops.copy(buff, newBuff, 2, 0, buff.length);
bops.writeUInt16BE(newBuff, buff.length, 0);
return newBuff;
}
exports.toBuffer = function (data) {
if (typeof data === 'string') {
return bops.from(data).buffer
} else if (bops.is(data)) {
// If data is a TypedArrayView (Uint8Array) then copy the buffer, so the
// underlying buffer will be exactly the right size. We care about this
// because the Chrome `sendTo` function will be passed the underlying
// ArrayBuffer.
var newBuf = bops.create(data.length)
bops.copy(data, newBuf, 0, 0, data.length)
return newBuf.buffer
} else if (data.buffer) {
return data.buffer
} else if (data instanceof ArrayBuffer) {
return data
} else {
throw new Error('Cannot convert data to ArrayBuffer type')
}
}
function encode(value, buffer, offset) {
var type = typeof value;
var length, size;
// Strings Bytes
if (type === "string") {
value = bops.from(value);
length = value.length;
// fixstr
if (length < 0x20) {
buffer[offset] = length | 0xa0;
bops.copy(value, buffer, offset + 1);
return 1 + length;
}
// str 8
if (length < 0x100) {
buffer[offset] = 0xd9;
bops.writeUInt8(buffer, length, offset + 1);
bops.copy(value, buffer, offset + 2);
return 2 + length;
}
// str 16
if (length < 0x10000) {
buffer[offset] = 0xda;
bops.writeUInt16BE(buffer, length, offset + 1);
bops.copy(value, buffer, offset + 3);
return 3 + length;
}
// str 32
if (length < 0x100000000) {
buffer[offset] = 0xdb;
bops.writeUInt32BE(buffer, length, offset + 1);
bops.copy(value, buffer, offset + 5);
return 5 + length;
}
}
if (bops.is(value)) {
length = value.length;
// bin 8
if (length < 0x100) {
buffer[offset] = 0xc4;
bops.writeUInt8(buffer, length, offset + 1);
bops.copy(value, buffer, offset + 2);
return 2 + length;
}
// bin 16
if (length < 0x10000) {
buffer[offset] = 0xd8;
bops.writeUInt16BE(buffer, length, offset + 1);
bops.copy(value, buffer, offset + 3);
return 3 + length;
}
// bin 32
if (length < 0x100000000) {
buffer[offset] = 0xd9;
bops.writeUInt32BE(buffer, length, offset + 1);
bops.copy(value, buffer, offset + 5);
return 5 + length;
}
}
if (type === "number") {
// Floating Point
if ((value << 0) !== value) {
buffer[offset] = 0xcb;
bops.writeDoubleBE(buffer, value, offset + 1);
return 9;
}
// Integers
if (value >=0) {
// positive fixnum
if (value < 0x80) {
buffer[offset] = value;
return 1;
}
// uint 8
if (value < 0x100) {
buffer[offset] = 0xcc;
buffer[offset + 1] = value;
return 2;
}
// uint 16
if (value < 0x10000) {
buffer[offset] = 0xcd;
bops.writeUInt16BE(buffer, value, offset + 1);
return 3;
}
// uint 32
if (value < 0x100000000) {
buffer[offset] = 0xce;
bops.writeUInt32BE(buffer, value, offset + 1);
return 5;
}
// uint 64
if (value < 0x10000000000000000) {
buffer[offset] = 0xcf;
bops.writeUInt64BE(buffer, value, offset + 1);
return 9;
}
throw new Error("Number too big 0x" + value.toString(16));
}
// negative fixnum
if (value >= -0x20) {
bops.writeInt8(buffer, value, offset);
return 1;
}
// int 8
if (value >= -0x80) {
buffer[offset] = 0xd0;
bops.writeInt8(buffer, value, offset + 1);
return 2;
}
// int 16
if (value >= -0x8000) {
buffer[offset] = 0xd1;
bops.writeInt16BE(buffer, value, offset + 1);
return 3;
}
// int 32
if (value >= -0x80000000) {
buffer[offset] = 0xd2;
bops.writeInt32BE(buffer, value, offset + 1);
return 5;
}
// int 64
if (value >= -0x8000000000000000) {
buffer[offset] = 0xd3;
bops.writeInt64BE(buffer, value, offset + 1);
return 9;
}
throw new Error("Number too small -0x" + value.toString(16).substr(1));
}
if (type === "undefined") {
buffer[offset] = 0xd4;
buffer[offset + 1] = 0x00; // fixext special type/value
buffer[offset + 2] = 0x00;
return 1;
}
// null
if (value === null) {
buffer[offset] = 0xc0;
return 1;
}
// Boolean
if (type === "boolean") {
buffer[offset] = value ? 0xc3 : 0xc2;
return 1;
}
// Custom toJSON function.
if (typeof value.toJSON === 'function') {
return encode(value.toJSON(), buffer, offset);
}
// Container Types
if (type === "object") {
size = 0;
var isArray = Array.isArray(value);
if (isArray) {
length = value.length;
}
else {
var keys = encodeableKeys(value);
length = keys.length;
}
// fixarray
if (length < 0x10) {
buffer[offset] = length | (isArray ? 0x90 : 0x80);
size = 1;
}
// array 16 / map 16
else if (length < 0x10000) {
buffer[offset] = isArray ? 0xdc : 0xde;
bops.writeUInt16BE(buffer, length, offset + 1);
size = 3;
}
// array 32 / map 32
else if (length < 0x100000000) {
buffer[offset] = isArray ? 0xdd : 0xdf;
bops.writeUInt32BE(buffer, length, offset + 1);
size = 5;
}
if (isArray) {
for (var i = 0; i < length; i++) {
size += encode(value[i], buffer, offset + size);
}
}
else {
for (var i = 0; i < length; i++) {
var key = keys[i];
size += encode(key, buffer, offset + size);
size += encode(value[key], buffer, offset + size);
}
}
return size;
}
if (type === "function") return undefined;
throw new Error("Unknown type " + type);
}
value.forEach(function(e) { bops.copy(e, buffer, offset + size); size += e.length; });
function insert() {
binary.copy(delta, output_buffer, out_idx, idx, command + idx)
idx += command
out_idx += command
}
function write_buffer(buffer, pos, src) {
bops.copy(src, buffer, pos);
return src.length;
}