How to use snappy - 10 common examples

(message[index++] << 16) |
    (message[index++] << 24);

  // Unpack and decompress if the message is OP_COMPRESSED
  if (type === opcodes.OP_COMPRESSED) {
    const requestID = message.readInt32LE(4);
    const responseTo = message.readInt32LE(8);
    const originalOpcode = message.readInt32LE(16);
    const uncompressedSize = message.readInt32LE(20);
    const compressorID = message.readUInt8(24);

    const compressedData = message.slice(25);
    let uncompressedData;
    switch (compressorID) {
      case compressorIDs.snappy:
        uncompressedData = Snappy.uncompressSync(compressedData);
        break;
      case compressorIDs.zlib:
        uncompressedData = zlib.inflateSync(compressedData);
        break;
      default:
        uncompressedData = compressedData;
    }

    if (uncompressedData.length !== uncompressedSize) {
      throw new Error(
        'corrupt wire protocol message: uncompressed message is not the correct size'
      );
    }

    // Reconstruct the msgHeader of the uncompressed opcode
    const newMsgHeader = Buffer(MESSAGE_HEADER_SIZE);

function createStringTable(data) {
        //create a stringtable
        //console.error(data);
        //extract the native buffer from the string_data ByteBuffer, with the offset removed
        var buf = data.string_data.toBuffer();
        if (data.data_compressed) {
            //decompress the string data with snappy
            //early source 2 replays may use LZSS, we can detect this by reading the first four bytes of buffer
            buf = snappy.uncompressSync(buf);
        }
        //pass the buffer and parse string table data from it
        var items = parseStringTableData(buf, data.num_entries, data.user_data_fixed_size, data.user_data_size);
        //console.error(items);
        //remove the buf and replace with items, which is a decoded version of it
        data.string_data = {};
        // Insert the items into the table as an object
        items.forEach(function(it) {
            data.string_data[it.index] = it;
        });
        /*
        // Apply the updates to baseline state
	    if t.name == "instancebaseline" {
	    	p.updateInstanceBaseline()
	    }
        */

//msgCompressed: = (command & dota.EDemoCommands_DEM_IsCompressed) == dota.EDemoCommands_DEM_IsCompressed
                var msgType = command & ~dota.EDemoCommands.DEM_IsCompressed;
                var msgCompressed = (command & dota.EDemoCommands.DEM_IsCompressed) === dota.EDemoCommands.DEM_IsCompressed;
                // Read the tick that the message corresponds with.
                //tick: = p.reader.readVarUint32()
                // This appears to actually be an int32, where a -1 means pre-game.
                /*
                if tick == 4294967295 {
                        tick = 0
                }
                */
                if (tick === 4294967295) {
                    tick = 0;
                }
                if (msgCompressed) {
                    buf = snappy.uncompressSync(buf);
                }
                var msg = {
                    tick: tick,
                    typeId: msgType,
                    size: size,
                    isCompressed: msgCompressed,
                    data: buf
                };
                return cb(null, msg);
            });
        });

//msgCompressed: = (command & dota.EDemoCommands_DEM_IsCompressed) == dota.EDemoCommands_DEM_IsCompressed
            var msgType = command & ~dota.EDemoCommands.DEM_IsCompressed;
            var msgCompressed = (command & dota.EDemoCommands.DEM_IsCompressed) === dota.EDemoCommands.DEM_IsCompressed;
            // Read the tick that the message corresponds with.
            //tick: = p.reader.readVarUint32()
            // This appears to actually be an int32, where a -1 means pre-game.
            /*
            if tick == 4294967295 {
                    tick = 0
            }
            */
            if (tick === 4294967295) {
                tick = 0;
            }
            if (msgCompressed) {
                buf = snappy.uncompressSync(buf);
            }
            var msg = {
                tick: tick,
                typeId: msgType,
                size: size,
                isCompressed: msgCompressed,
                data: buf
            };
            return cb(err, msg);
        });
    });

this.buffer.consume(4 + size)

  if (!this.foundIdentifier && type !== 'identifier')
    return callback(new Error('malformed input: must begin with an identifier'))

  if (type === 'identifier') {
    if(!bufferEqual(data, IDENTIFIER))
      return callback(new Error('malformed input: bad identifier'))

    this.foundIdentifier = true
    return this._parse(callback)
  }

  if (type === 'compressed') {
    // TODO: check that the checksum matches
    snappy.uncompress(data.slice(4), { asBuffer: this.asBuffer }, function (err, raw) {
      if(err) {
        return callback(err)
      }
      self.push(raw)
      self._parse(callback)
    })
    return
  }

  if (type === 'uncompressed') {
    // TODO: check that the checksum matches
    data = data.slice(4)

    if (!this.asBuffer)
      data = data.toString()

snappy: function (buf, cb) {
            // Avro appends checksums to compressed blocks, which we skip here.
            return snappy.uncompress(buf.slice(0, buf.length - 4), cb);
        }
    };

var fs = require('fs')
  , path = require('path')

  , snappy = require('snappy')
  , snappyjs = require('../../snappy.js')

  , input = fs.readFileSync(path.resolve(__dirname, '../fixtures/urls.10K-compressed.bin'))

console.log('uncompress')
console.time('snappy')
for(var i = 0; i < 100; ++i)
  snappy.uncompressSync(input)
console.timeEnd('snappy')

console.time('snappy.js')
for(var i = 0; i < 100; ++i)
  snappyjs.uncompress(input)
console.timeEnd('snappy.js')

console.log('isValidCompressed')
console.time('snappy')
for(var i = 0; i < 100; ++i)
  snappy.isValidCompressedSync(input)
console.timeEnd('snappy')

console.time('snappy.js')
for(var i = 0; i < 100; ++i)
  snappyjs.isValidCompressed(input)

console.log('uncompress')
console.time('snappy')
for(var i = 0; i < 100; ++i)
  snappy.uncompressSync(input)
console.timeEnd('snappy')

console.time('snappy.js')
for(var i = 0; i < 100; ++i)
  snappyjs.uncompress(input)
console.timeEnd('snappy.js')

console.log('isValidCompressed')
console.time('snappy')
for(var i = 0; i < 100; ++i)
  snappy.isValidCompressedSync(input)
console.timeEnd('snappy')

console.time('snappy.js')
for(var i = 0; i < 100; ++i)
  snappyjs.isValidCompressed(input)
console.timeEnd('snappy.js')

function sendMessageToClient(destination,message){
    if(debug) console.log(message);
    if(message.length<1000) clientSocket.send(['','c'+destination,'',message]);
    else{
        message=snappy.compressSync(message);
        clientSocket.send(['','c'+destination,'c',message]);
    }
}

function sendMessageToServer(destination,message){
    if(debug) console.log('Client: ',message);
    if(message.length<1000) clientSocket.send(['','s'+destination,'',message]);
    else{
        message=snappy.compressSync(message);
        clientSocket.send(['','s'+destination,'c',message]);
    }
}
clientSocket.on('message',function(){