gremlin
Version:
JavaScript Gremlin Language Variant
251 lines (222 loc) • 8.74 kB
JavaScript
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/**
* @author Igor Ostapenko
*/
;
const { Buffer } = require('buffer');
const Bytecode = require('../../../../process/bytecode');
const t = require('../../../../process/traversal');
module.exports = class BytecodeSerializer {
constructor(ioc) {
this.ioc = ioc;
this.ioc.serializers[ioc.DataType.BYTECODE] = this;
}
canBeUsedFor(value) {
return value instanceof Bytecode || value instanceof t.Traversal;
}
serialize(item, fullyQualifiedFormat = true) {
if (item === undefined || item === null) {
if (fullyQualifiedFormat) {
return Buffer.from([this.ioc.DataType.BYTECODE, 0x01]);
}
const steps_length = [0x00, 0x00, 0x00, 0x00]; // 0
const sources_length = [0x00, 0x00, 0x00, 0x00]; // 0
return Buffer.from([...steps_length, ...sources_length]);
}
if (item instanceof t.Traversal) {
item = item.getBytecode();
}
const bufs = [];
if (fullyQualifiedFormat) {
bufs.push(Buffer.from([this.ioc.DataType.BYTECODE, 0x00]));
}
// {steps_length}{step_0}...{step_n}
bufs.push(this.ioc.intSerializer.serialize(item.stepInstructions.length, false)); // TODO: what if steps_length > INT32_MAX
for (let i = 0; i < item.stepInstructions.length; i++) {
// {step_i} is composed of {name}{values_length}{value_0}...{value_n}
const step = item.stepInstructions[i];
const name = step[0];
const values_length = step.length - 1;
bufs.push(this.ioc.stringSerializer.serialize(name, false));
bufs.push(this.ioc.intSerializer.serialize(values_length, false));
for (let j = 0; j < values_length; j++) {
bufs.push(this.ioc.anySerializer.serialize(step[1 + j], true));
}
}
// {sources_length}{source_0}...{source_n}
bufs.push(this.ioc.intSerializer.serialize(item.sourceInstructions.length, false)); // TODO: what if sources_length > INT32_MAX
for (let i = 0; i < item.sourceInstructions.length; i++) {
// {source_i} is composed of {name}{values_length}{value_0}...{value_n}
const source = item.sourceInstructions[i];
const name = source[0];
const values_length = source.length - 1;
bufs.push(this.ioc.stringSerializer.serialize(name, false));
bufs.push(this.ioc.intSerializer.serialize(values_length, false));
for (let j = 0; j < values_length; j++) {
bufs.push(this.ioc.anySerializer.serialize(source[1 + j], true));
}
}
return Buffer.concat(bufs);
}
deserialize(buffer, fullyQualifiedFormat = true) {
let len = 0;
let cursor = buffer;
try {
if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
throw new Error('buffer is missing');
}
if (buffer.length < 1) {
throw new Error('buffer is empty');
}
if (fullyQualifiedFormat) {
const type_code = cursor.readUInt8();
len++;
if (type_code !== this.ioc.DataType.BYTECODE) {
throw new Error('unexpected {type_code}');
}
cursor = cursor.slice(1);
if (cursor.length < 1) {
throw new Error('{value_flag} is missing');
}
const value_flag = cursor.readUInt8();
len++;
if (value_flag === 1) {
return { v: null, len };
}
if (value_flag !== 0) {
throw new Error('unexpected {value_flag}');
}
cursor = cursor.slice(1);
}
const v = new Bytecode();
// steps
let steps_length, steps_length_len;
try {
({ v: steps_length, len: steps_length_len } = this.ioc.intSerializer.deserialize(cursor, false));
len += steps_length_len;
} catch (err) {
err.message = '{steps_length}: ' + err.message;
throw err;
}
if (steps_length < 0) {
throw new Error('{steps_length} is less than zero');
}
cursor = cursor.slice(steps_length_len);
// {step_i} is composed of {name}{values_length}{value_0}...{value_n}
for (let i = 0; i < steps_length; i++) {
// {name} is a String
let name, name_len;
try {
({ v: name, len: name_len } = this.ioc.stringSerializer.deserialize(cursor, false));
len += name_len;
} catch (err) {
err.message = `{step_${i}} {name}: ` + err.message;
throw err;
}
cursor = cursor.slice(name_len);
// {values_length} is an Int describing the amount values
let values_length, values_length_len;
try {
({ v: values_length, len: values_length_len } = this.ioc.intSerializer.deserialize(cursor, false));
len += values_length_len;
} catch (err) {
err.message = `{step_${i}} {values_length}: ` + err.message;
throw err;
}
if (values_length < 0) {
throw new Error(`{step_${i}} {values_length} is less than zero`);
}
cursor = cursor.slice(values_length_len);
// {value_i} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value} describing the step argument
const values = [];
let value, value_len;
for (let j = 0; j < values_length; j++) {
try {
({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
len += value_len;
values.push(value);
} catch (err) {
err.message = `{step_${i}} {value_${j}}: ` + err.message;
throw err;
}
cursor = cursor.slice(value_len);
}
v.addStep(name, values);
}
// sources
let sources_length, sources_length_len;
try {
({ v: sources_length, len: sources_length_len } = this.ioc.intSerializer.deserialize(cursor, false));
len += sources_length_len;
} catch (err) {
err.message = '{sources_length}: ' + err.message;
throw err;
}
if (sources_length < 0) {
throw new Error('{sources_length} is less than zero');
}
cursor = cursor.slice(sources_length_len);
// {source_i} is composed of {name}{values_length}{value_0}...{value_n}
for (let i = 0; i < sources_length; i++) {
// {name} is a String
let name, name_len;
try {
({ v: name, len: name_len } = this.ioc.stringSerializer.deserialize(cursor, false));
len += name_len;
} catch (err) {
err.message = `{source_${i}} {name}: ` + err.message;
throw err;
}
cursor = cursor.slice(name_len);
// {values_length} is an Int describing the amount values
let values_length, values_length_len;
try {
({ v: values_length, len: values_length_len } = this.ioc.intSerializer.deserialize(cursor, false));
len += values_length_len;
} catch (err) {
err.message = `{source_${i}} {values_length}: ` + err.message;
throw err;
}
if (values_length < 0) {
throw new Error(`{source_${i}} {values_length} is less than zero`);
}
cursor = cursor.slice(values_length_len);
// {value_i} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value}
const values = [];
let value, value_len;
for (let j = 0; j < values_length; j++) {
try {
({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
len += value_len;
values.push(value);
} catch (err) {
err.message = `{source_${i}} {value_${j}}: ` + err.message;
throw err;
}
cursor = cursor.slice(value_len);
}
v.addSource(name, values);
}
return { v, len };
} catch (err) {
throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
}
}
};