Namespace.prototype.emit = function(ev){
if (~exports.events.indexOf(ev)) {
emit.apply(this, arguments);
} else {
// set up packet object
var args = Array.prototype.slice.call(arguments);
var parserType = parser.EVENT; // default
if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary
var packet = { type: parserType, data: args };
if ('function' == typeof args[args.length - 1]) {
throw new Error('Callbacks are not supported when broadcasting');
}
this.adapter.broadcast(packet, {
rooms: this.rooms,
flags: this.flags
});
delete this.rooms;
delete this.flags;
}
return this;
};
Socket.prototype.emit = function(ev){
if (events.hasOwnProperty(ev)) {
emit.apply(this, arguments);
return this;
}
var args = toArray(arguments);
var parserType = parser.EVENT; // default
if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary
var packet = { type: parserType, data: args };
packet.options = {};
packet.options.compress = !this.flags || false !== this.flags.compress;
// event ack callback
if ('function' == typeof args[args.length - 1]) {
debug('emitting packet with ack id %d', this.ids);
this.acks[this.ids] = args.pop();
packet.id = this.ids++;
}
if (this.connected) {
this.packet(packet);
} else {
this.sendBuffer.push(packet);
}
delete this.flags;
return this;
};
Socketiop2p.prototype.emit = function (data, cb) {
var self = this
var argsObj = cb || {}
var encoder = new parser.Encoder()
if (this._peerEvents.hasOwnProperty(data) || argsObj.fromSocket) {
emitfn.apply(this, arguments)
} else if (this.usePeerConnection || !this.useSockets) {
var args = toArray(arguments)
var parserType = parser.EVENT // default
if (hasBin(args)) { parserType = parser.BINARY_EVENT } // binary
var packet = { type: parserType, data: args }
encoder.encode(packet, function (encodedPackets) {
if (encodedPackets[1] instanceof ArrayBuffer) {
self._sendArray(encodedPackets)
} else if (encodedPackets) {
for (var i = 0; i < encodedPackets.length; i++) {
self._send(encodedPackets[i])
}
} else {
throw new Error('Encoding error')
}
})
} else {
this.socket.emit(data, cb)
}
}
exports.encodePayload = function (packets, supportsBinary, callback) {
if (typeof supportsBinary == 'function') {
callback = supportsBinary;
supportsBinary = null;
}
var isBinary = hasBinary(packets);
if (supportsBinary && isBinary) {
if (Blob && !dontSendBlobs) {
return exports.encodePayloadAsBlob(packets, callback);
}
return exports.encodePayloadAsArrayBuffer(packets, callback);
}
if (!packets.length) {
return callback('0:');
}
function setLengthHeader(message) {
return message.length + ':' + message;
}
function encodeOne(packet, doneCallback) {
exports.encodePacket(packet, !isBinary ? false : supportsBinary, true, function(message) {
doneCallback(null, setLengthHeader(message));
});
}
map(packets, encodeOne, function(err, results) {
return callback(results.join(''));
});
};
return function(){
// prevent double callbacks
if (sent) return;
var args = Array.prototype.slice.call(arguments);
debug('sending ack %j', args);
var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;
self.packet({
id: id,
type: type,
data: args
});
};
return function(){
// prevent double callbacks
if (sent) return;
sent = true;
var args = toArray(arguments);
debug('sending ack %j', args);
var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;
self.packet({
type: type,
id: id,
data: args
});
};
Socket.prototype.emit = function(ev){
if (~exports.events.indexOf(ev)) {
emit.apply(this, arguments);
} else {
var args = Array.prototype.slice.call(arguments);
var packet = {};
packet.type = hasBin(args) ? parser.BINARY_EVENT : parser.EVENT;
packet.data = args;
var flags = this.flags || {};
// access last argument to see if it's an ACK callback
if ('function' == typeof args[args.length - 1]) {
if (this._rooms || flags.broadcast) {
throw new Error('Callbacks are not supported when broadcasting');
}
debug('emitting packet with ack id %d', this.nsp.ids);
this.acks[this.nsp.ids] = args.pop();
packet.id = this.nsp.ids++;
}
if (this._rooms || flags.broadcast) {
this.adapter.broadcast(packet, {
except: [this.id],
rooms: this._rooms,
flags: flags
});
} else {
// dispatch packet
this.packet(packet, {
volatile: flags.volatile,
compress: flags.compress
});
}
// reset flags
delete this._rooms;
delete this.flags;
}
return this;
};
Emitter.prototype.emit = function () {
var self = this;
// packet
var args = Array.prototype.slice.call(arguments);
var packet = {};
packet.type = hasBin(args) ? parser.BINARY_EVENT : parser.EVENT;
packet.data = args;
// set namespace to packet
if (this._flags.nsp) {
packet.nsp = this._flags.nsp;
delete this._flags.nsp;
} else {
packet.nsp = '/';
}
var opts = {
rooms: this._rooms,
flags: this._flags
};
var msg = msgpack.encode([uid, packet, opts]);
// publish
if (opts.rooms && opts.rooms.length) {
opts.rooms.forEach((room) => {
const chnRoom = this.prefix + "#" + room;
self.redis.publish(chnRoom, msg);
});
} else {
this.redis.publish(this.prefix, msg);
}
// reset state
this._rooms = [];
this._flags = {};
return this;
};