diffusion/src/node_modules/services/timeseries/range-query-result-serialiser.js

Diffusion JavaScript client

var RangeQueryResult = require('./range-query-result');
var EventMetadata = require('./time-series-event-metadata');
var Event = require('./time-series-event');

var DataTypes = require('data/datatypes');
var Codec = require('io/codec');
var Long = require('long');

var ORIGINAL_EVENT      = 0;
var EDIT_EVENT          = 1;
var METADATA_OFFSETS    = 2;
var AUTHOR_ENCODING     = 3;

function Offsets(sequence, timestamp) {
    this.sequence = sequence;
    this.timestamp = timestamp;

    this.with = function(s, t) {
        if (sequence.equals(s) && timestamp.equals(t)) {
            return this;
        }

        return new Offsets(sequence, timestamp);
    };

    this.equals = function(other) {
        if (other && other instanceof Offsets) {
            return sequence.equals(other.sequence) &&
                   timestamp.equals(other.timestamp);
        }

        return false;
    };
}

// TODO: Rework codec to use Int64 impl, replace use of Long.
Offsets.IDENTITY = new Offsets(Long.MAX_VALUE, Long.MAX_VALUE);

function readMetadata(input, offsets, codeToAuthor) {
    var sequence = Codec.readInt64(input).add(offsets.sequence);
    var timestamp = Codec.readInt64(input).add(offsets.timestamp);

    var code = Codec.readBytes(input);
    var decoded = codeToAuthor[code];
    var author = decoded ? decoded : code.toString('utf-8');

    return new EventMetadata(sequence.toNumber(), timestamp.toNumber(), author);
}

function readOriginalEvent(input, offsets, codeToAuthor) {
    var metadata = readMetadata(input, offsets, codeToAuthor);
    return Event.create(metadata, metadata, Codec.readBytes(input));
}

function readEditEvent(input, offsets, codeToAuthor) {
    var originalEvent = readMetadata(input, offsets, codeToAuthor);
    var metadata = readMetadata(input, offsets, codeToAuthor);

    return Event.create(metadata, originalEvent, Codec.readBytes(input));
}

function readMetadataOffsets(input) {
    return new Offsets(Codec.readInt64(input), Codec.readInt64(input));
}

function readAuthorEncoding(input, codeToAuthor) {
    var code = Codec.readBytes(input);
    codeToAuthor[code] = Codec.readString(input);
}

module.exports = {
    read : function(input) {
        var dataType = DataTypes.get(Codec.readString(input));
        var selectedCount = Codec.readInt64(input);

        var offsets = new Offsets(Long.ZERO, Long.ZERO);
        var codeToAuthor = {};
        var events = [];

        var limit = Codec.readInt32(input);

        for (var i = 0; i < limit; ++i) {
            switch (Codec.readByte(input)) {
                case ORIGINAL_EVENT :
                    events.push(readOriginalEvent(input, offsets, codeToAuthor));
                    break;
                case EDIT_EVENT :
                    events.push(readEditEvent(input, offsets, codeToAuthor));
                    break;
                case METADATA_OFFSETS :
                    offsets = readMetadataOffsets(input);
                    break;
                case AUTHOR_ENCODING :
                    readAuthorEncoding(input, codeToAuthor);
                    break;
                default:
                    readAuthorEncoding(input, codeToAuthor);
            }
        }

        return new RangeQueryResult(dataType, selectedCount, events);
    },
    write : function() {
        // No-op for client
    }
};