diffusion/src/node_modules/timeseries/time-series-event-datatype.js

Diffusion JavaScript client

var AbstractDataType = require('data/abstract-datatype');
var BytesImpl = require('data/bytes-impl');

var BufferOutputStream = require('io/buffer-output-stream');
var BufferInputStream = require('io/buffer-input-stream');

var Codec = require('io/codec');

var EventMetadataSerialiser = require('services/timeseries/time-series-event-metadata-serialiser');
var EventImpl = require('services/timeseries/time-series-event');
var Event = require('../../features/timeseries').Event;

// Event type constants
var ORIGINAL_EVENT = 0;
var EDIT_EVENT = 1;

function eventToBytes(valueToBytes, event) {
    if (!event) {
        throw new Error("Cannot convert null event to Bytes");
    }

    return writeValue(valueToBytes, event);
}

function writeValue(valueToBytes, event) {
    var output = new BufferOutputStream();

    if (event.isEditEvent) {
        Codec.writeByte(output, EDIT_EVENT);
        EventMetadataSerialiser.write(output, event.originalEvent);
    } else {
        Codec.writeByte(output, ORIGINAL_EVENT);
    }

    EventMetadataSerialiser.write(output, event);

    var serialised = valueToBytes(event.value);
    Codec.writeBytes(output, serialised.$buffer);

    return new BytesImpl(output.getBuffer());
}

function bytesToEvent(bytesToValue, bytes) {
    var input = new BufferInputStream(bytes.$buffer);

    var eventType = Codec.readByte(input);

    switch (eventType) {
        case ORIGINAL_EVENT :
            return readOriginalEvent(bytesToValue, input);
        case EDIT_EVENT :
            return readEditEvent(bytesToValue, input);
        default :
            throw new Error('Unrecognised event type: ' + eventType);
    }
}

function readOriginalEvent(bytesToValue, input) {
    var metadata = EventMetadataSerialiser.read(input);
    var value = bytesToValue(Codec.readBytes(input));

    return EventImpl.create(metadata, metadata, value);
}

function readEditEvent(bytesToValue, input) {
    var originalEvent = EventMetadataSerialiser.read(input);
    var metadata = EventMetadataSerialiser.read(input);
    var value = bytesToValue(Codec.readBytes(input));

    return EventImpl.create(metadata, originalEvent, value);
}

function implementation(b, o, l) {
    return new BytesImpl(b, o, l);
}

function TimeSeriesEventDataType(name, bytesToValue, valueToBytes) {
    AbstractDataType.call(
        this,
        name,
        Event,
        implementation,
        function (e) {
            return eventToBytes(valueToBytes, e);
        },
        function(b) {
            return bytesToEvent(bytesToValue, b);
        },
        [],
        true);

    this.writeValue = function(event) {
        return writeValue(valueToBytes, event);
    };

    this.validate = function() {
        // no-op: validates on read
    };
}

module.exports = TimeSeriesEventDataType;

module.exports.create = function(delegate) {
    return new TimeSeriesEventDataType("timeseriesevent-" + delegate.name(), delegate.readValue, delegate.toBytes);
};