From b8182dd7ffe55e268937c89f17294097a8b7e678 Mon Sep 17 00:00:00 2001 From: Denis Chaplygin Date: Mon, 26 Aug 2019 14:03:29 +0300 Subject: [PATCH] Replaced 'in' and 'out' at the flatbuffers 'instersection' object with 'in_bearing' and 'out_bearing' to get flatbuffers schema javascript friendly. Added a cucumber test for flatbuffers support. --- features/nearest/projection.feature | 25 + features/step_definitions/nearest.js | 54 + features/support/fbresult_generated.js | 3217 +++++++++++++++++ features/support/flatbuffers.js | 1259 +++++++ .../api/flatbuffers/fbresult_generated.h | 60 +- include/engine/api/flatbuffers/route.fbs | 4 +- include/engine/api/route_api.hpp | 4 +- unit_tests/library/route.cpp | 4 +- 8 files changed, 4591 insertions(+), 36 deletions(-) create mode 100644 features/support/fbresult_generated.js create mode 100644 features/support/flatbuffers.js diff --git a/features/nearest/projection.feature b/features/nearest/projection.feature index 3d9e6aa30..dc3ba94c0 100644 --- a/features/nearest/projection.feature +++ b/features/nearest/projection.feature @@ -111,3 +111,28 @@ Feature: Locating Nearest node on a Way - basic projection onto way | 7 | b | | 8 | a | | 9 | b | + + Scenario: Nearest - easy-west way with flatbuffers + Given the node map + """ + 0 1 2 3 4 + a x b + 5 6 7 8 9 + """ + + And the ways + | nodes | + | ab | + + When I request nearest with flatbuffers I should get + | in | out | + | 0 | a | + | 1 | a | + | 2 | x | + | 3 | b | + | 4 | b | + | 5 | a | + | 6 | a | + | 7 | x | + | 8 | b | + | 9 | b | diff --git a/features/step_definitions/nearest.js b/features/step_definitions/nearest.js index f5627b842..56bbd5843 100644 --- a/features/step_definitions/nearest.js +++ b/features/step_definitions/nearest.js @@ -1,5 +1,8 @@ var util = require('util'); +var flatbuffers = require('../support/flatbuffers').flatbuffers; +var FBResult = require('../support/fbresult_generated').osrm.engine.api.fbresult.FBResult; + module.exports = function () { this.When(/^I request nearest I should get$/, (table, callback) => { this.reprocessAndLoadData((e) => { @@ -43,4 +46,55 @@ module.exports = function () { this.processRowsAndDiff(table, testRow, callback); }); }); + + this.When(/^I request nearest with flatbuffers I should get$/, (table, callback) => { + this.reprocessAndLoadData((e) => { + if (e) return callback(e); + var testRow = (row, ri, cb) => { + var inNode = this.findNodeByName(row.in); + if (!inNode) throw new Error(util.format('*** unknown in-node "%s"', row.in)); + + var outNode = this.findNodeByName(row.out); + if (!outNode) throw new Error(util.format('*** unknown out-node "%s"', row.out)); + + this.queryParams.output = 'flatbuffers'; + this.requestNearest(inNode, this.queryParams, (err, response) => { + if (err) return cb(err); + var coord; + + if (response.statusCode === 200 && response.body.length) { + var body = response.body; + var bytes = new Uint8Array(body.length); + for (var indx = 0; indx < body.length; ++indx) { + bytes[indx] = body.charCodeAt(indx); + } + var buf = new flatbuffers.ByteBuffer(bytes); + var fb = FBResult.getRootAsFBResult(buf); + var location = fb.waypoints(0).location(); + + coord = [location.longitute(), location.latitude()]; + + var got = { in: row.in, out: row.out }; + + Object.keys(row).forEach((key) => { + if (key === 'out') { + if (this.FuzzyMatch.matchLocation(coord, outNode)) { + got[key] = row[key]; + } else { + row[key] = util.format('%s [%d,%d]', row[key], outNode.lat, outNode.lon); + } + } + }); + + cb(null, got); + } + else { + cb(); + } + }); + }; + + this.processRowsAndDiff(table, testRow, callback); + }); + }); }; diff --git a/features/support/fbresult_generated.js b/features/support/fbresult_generated.js new file mode 100644 index 000000000..9e10e1606 --- /dev/null +++ b/features/support/fbresult_generated.js @@ -0,0 +1,3217 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var osrm = osrm || {}; + +/** + * @const + * @namespace + */ +osrm.engine = osrm.engine || {}; + +/** + * @const + * @namespace + */ +osrm.engine.api = osrm.engine.api || {}; + +/** + * @const + * @namespace + */ +osrm.engine.api.fbresult = osrm.engine.api.fbresult || {}; + +/** + * @enum {number} + */ +osrm.engine.api.fbresult.ManeuverType = { + Turn: 0, + NewName: 1, + Depart: 2, + Arrive: 3, + Merge: 4, + OnRamp: 5, + OffRamp: 6, + Fork: 7, + EndOfRoad: 8, + Continue: 9, + Roundabout: 10, + Rotary: 11, + RoundaboutTurn: 12, + Notification: 13, + ExitRoundabout: 14, + ExitRotary: 15 +}; + +/** + * @enum {string} + */ +osrm.engine.api.fbresult.ManeuverTypeName = { + 0: 'Turn', + 1: 'NewName', + 2: 'Depart', + 3: 'Arrive', + 4: 'Merge', + 5: 'OnRamp', + 6: 'OffRamp', + 7: 'Fork', + 8: 'EndOfRoad', + 9: 'Continue', + 10: 'Roundabout', + 11: 'Rotary', + 12: 'RoundaboutTurn', + 13: 'Notification', + 14: 'ExitRoundabout', + 15: 'ExitRotary' +}; + +/** + * @enum {number} + */ +osrm.engine.api.fbresult.Turn = { + None: 0, + UTurn: 1, + SharpRight: 2, + Right: 3, + SlightRight: 4, + Straight: 5, + SlightLeft: 6, + Left: 7, + SharpLeft: 8 +}; + +/** + * @enum {string} + */ +osrm.engine.api.fbresult.TurnName = { + 0: 'None', + 1: 'UTurn', + 2: 'SharpRight', + 3: 'Right', + 4: 'SlightRight', + 5: 'Straight', + 6: 'SlightLeft', + 7: 'Left', + 8: 'SharpLeft' +}; + +/** + * @constructor + */ +osrm.engine.api.fbresult.Position = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Position} + */ +osrm.engine.api.fbresult.Position.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Position.prototype.longitute = function() { + return this.bb.readFloat32(this.bb_pos); +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Position.prototype.latitude = function() { + return this.bb.readFloat32(this.bb_pos + 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} longitute + * @param {number} latitude + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Position.createPosition = function(builder, longitute, latitude) { + builder.prep(4, 8); + builder.writeFloat32(latitude); + builder.writeFloat32(longitute); + return builder.offset(); +}; + +/** + * @constructor + */ +osrm.engine.api.fbresult.Uint64Pair = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Uint64Pair} + */ +osrm.engine.api.fbresult.Uint64Pair.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @returns {flatbuffers.Long} + */ +osrm.engine.api.fbresult.Uint64Pair.prototype.first = function() { + return this.bb.readUint64(this.bb_pos); +}; + +/** + * @returns {flatbuffers.Long} + */ +osrm.engine.api.fbresult.Uint64Pair.prototype.second = function() { + return this.bb.readUint64(this.bb_pos + 8); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} first + * @param {flatbuffers.Long} second + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Uint64Pair.createUint64Pair = function(builder, first, second) { + builder.prep(8, 16); + builder.writeInt64(second); + builder.writeInt64(first); + return builder.offset(); +}; + +/** + * @constructor + */ +osrm.engine.api.fbresult.Waypoint = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Waypoint} + */ +osrm.engine.api.fbresult.Waypoint.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Waypoint=} obj + * @returns {osrm.engine.api.fbresult.Waypoint} + */ +osrm.engine.api.fbresult.Waypoint.getRootAsWaypoint = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Waypoint).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Waypoint=} obj + * @returns {osrm.engine.api.fbresult.Waypoint} + */ +osrm.engine.api.fbresult.Waypoint.getSizePrefixedRootAsWaypoint = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Waypoint).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Waypoint.prototype.hint = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Waypoint.prototype.distance = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Waypoint.prototype.name = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {osrm.engine.api.fbresult.Position=} obj + * @returns {osrm.engine.api.fbresult.Position|null} + */ +osrm.engine.api.fbresult.Waypoint.prototype.location = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? (obj || new osrm.engine.api.fbresult.Position).__init(this.bb_pos + offset, this.bb) : null; +}; + +/** + * @param {osrm.engine.api.fbresult.Uint64Pair=} obj + * @returns {osrm.engine.api.fbresult.Uint64Pair|null} + */ +osrm.engine.api.fbresult.Waypoint.prototype.nodes = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? (obj || new osrm.engine.api.fbresult.Uint64Pair).__init(this.bb_pos + offset, this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Waypoint.prototype.matchingsIndex = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Waypoint.prototype.waypointIndex = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Waypoint.prototype.alternativesCount = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Waypoint.prototype.tripsIndex = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Waypoint.startWaypoint = function(builder) { + builder.startObject(9); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} hintOffset + */ +osrm.engine.api.fbresult.Waypoint.addHint = function(builder, hintOffset) { + builder.addFieldOffset(0, hintOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} distance + */ +osrm.engine.api.fbresult.Waypoint.addDistance = function(builder, distance) { + builder.addFieldFloat32(1, distance, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} nameOffset + */ +osrm.engine.api.fbresult.Waypoint.addName = function(builder, nameOffset) { + builder.addFieldOffset(2, nameOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} locationOffset + */ +osrm.engine.api.fbresult.Waypoint.addLocation = function(builder, locationOffset) { + builder.addFieldStruct(3, locationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} nodesOffset + */ +osrm.engine.api.fbresult.Waypoint.addNodes = function(builder, nodesOffset) { + builder.addFieldStruct(4, nodesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} matchingsIndex + */ +osrm.engine.api.fbresult.Waypoint.addMatchingsIndex = function(builder, matchingsIndex) { + builder.addFieldInt32(5, matchingsIndex, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} waypointIndex + */ +osrm.engine.api.fbresult.Waypoint.addWaypointIndex = function(builder, waypointIndex) { + builder.addFieldInt32(6, waypointIndex, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} alternativesCount + */ +osrm.engine.api.fbresult.Waypoint.addAlternativesCount = function(builder, alternativesCount) { + builder.addFieldInt32(7, alternativesCount, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} tripsIndex + */ +osrm.engine.api.fbresult.Waypoint.addTripsIndex = function(builder, tripsIndex) { + builder.addFieldInt32(8, tripsIndex, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Waypoint.endWaypoint = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} hintOffset + * @param {number} distance + * @param {flatbuffers.Offset} nameOffset + * @param {flatbuffers.Offset} locationOffset + * @param {flatbuffers.Offset} nodesOffset + * @param {number} matchingsIndex + * @param {number} waypointIndex + * @param {number} alternativesCount + * @param {number} tripsIndex + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Waypoint.createWaypoint = function(builder, hintOffset, distance, nameOffset, locationOffset, nodesOffset, matchingsIndex, waypointIndex, alternativesCount, tripsIndex) { + osrm.engine.api.fbresult.Waypoint.startWaypoint(builder); + osrm.engine.api.fbresult.Waypoint.addHint(builder, hintOffset); + osrm.engine.api.fbresult.Waypoint.addDistance(builder, distance); + osrm.engine.api.fbresult.Waypoint.addName(builder, nameOffset); + osrm.engine.api.fbresult.Waypoint.addLocation(builder, locationOffset); + osrm.engine.api.fbresult.Waypoint.addNodes(builder, nodesOffset); + osrm.engine.api.fbresult.Waypoint.addMatchingsIndex(builder, matchingsIndex); + osrm.engine.api.fbresult.Waypoint.addWaypointIndex(builder, waypointIndex); + osrm.engine.api.fbresult.Waypoint.addAlternativesCount(builder, alternativesCount); + osrm.engine.api.fbresult.Waypoint.addTripsIndex(builder, tripsIndex); + return osrm.engine.api.fbresult.Waypoint.endWaypoint(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.Metadata = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Metadata} + */ +osrm.engine.api.fbresult.Metadata.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Metadata=} obj + * @returns {osrm.engine.api.fbresult.Metadata} + */ +osrm.engine.api.fbresult.Metadata.getRootAsMetadata = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Metadata).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Metadata=} obj + * @returns {osrm.engine.api.fbresult.Metadata} + */ +osrm.engine.api.fbresult.Metadata.getSizePrefixedRootAsMetadata = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Metadata).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {number} index + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +osrm.engine.api.fbresult.Metadata.prototype.datasourceNames = function(index, optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Metadata.prototype.datasourceNamesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Metadata.startMetadata = function(builder) { + builder.startObject(1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} datasourceNamesOffset + */ +osrm.engine.api.fbresult.Metadata.addDatasourceNames = function(builder, datasourceNamesOffset) { + builder.addFieldOffset(0, datasourceNamesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Metadata.createDatasourceNamesVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Metadata.startDatasourceNamesVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Metadata.endMetadata = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} datasourceNamesOffset + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Metadata.createMetadata = function(builder, datasourceNamesOffset) { + osrm.engine.api.fbresult.Metadata.startMetadata(builder); + osrm.engine.api.fbresult.Metadata.addDatasourceNames(builder, datasourceNamesOffset); + return osrm.engine.api.fbresult.Metadata.endMetadata(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.Annotation = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Annotation} + */ +osrm.engine.api.fbresult.Annotation.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Annotation=} obj + * @returns {osrm.engine.api.fbresult.Annotation} + */ +osrm.engine.api.fbresult.Annotation.getRootAsAnnotation = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Annotation).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Annotation=} obj + * @returns {osrm.engine.api.fbresult.Annotation} + */ +osrm.engine.api.fbresult.Annotation.getSizePrefixedRootAsAnnotation = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Annotation).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.distance = function(index) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.distanceLength = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +osrm.engine.api.fbresult.Annotation.prototype.distanceArray = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.duration = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.durationLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +osrm.engine.api.fbresult.Annotation.prototype.durationArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.datasources = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.datasourcesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +osrm.engine.api.fbresult.Annotation.prototype.datasourcesArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.nodes = function(index) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.nodesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +osrm.engine.api.fbresult.Annotation.prototype.nodesArray = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.weight = function(index) { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.weightLength = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +osrm.engine.api.fbresult.Annotation.prototype.weightArray = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.speed = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Annotation.prototype.speedLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Float32Array} + */ +osrm.engine.api.fbresult.Annotation.prototype.speedArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {osrm.engine.api.fbresult.Metadata=} obj + * @returns {osrm.engine.api.fbresult.Metadata|null} + */ +osrm.engine.api.fbresult.Annotation.prototype.metadata = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? (obj || new osrm.engine.api.fbresult.Metadata).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Annotation.startAnnotation = function(builder) { + builder.startObject(7); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} distanceOffset + */ +osrm.engine.api.fbresult.Annotation.addDistance = function(builder, distanceOffset) { + builder.addFieldOffset(0, distanceOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Annotation.createDistanceVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Annotation.startDistanceVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationOffset + */ +osrm.engine.api.fbresult.Annotation.addDuration = function(builder, durationOffset) { + builder.addFieldOffset(1, durationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Annotation.createDurationVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Annotation.startDurationVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} datasourcesOffset + */ +osrm.engine.api.fbresult.Annotation.addDatasources = function(builder, datasourcesOffset) { + builder.addFieldOffset(2, datasourcesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Annotation.createDatasourcesVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Annotation.startDatasourcesVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} nodesOffset + */ +osrm.engine.api.fbresult.Annotation.addNodes = function(builder, nodesOffset) { + builder.addFieldOffset(3, nodesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Annotation.createNodesVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Annotation.startNodesVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} weightOffset + */ +osrm.engine.api.fbresult.Annotation.addWeight = function(builder, weightOffset) { + builder.addFieldOffset(4, weightOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Annotation.createWeightVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Annotation.startWeightVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} speedOffset + */ +osrm.engine.api.fbresult.Annotation.addSpeed = function(builder, speedOffset) { + builder.addFieldOffset(5, speedOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Annotation.createSpeedVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addFloat32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Annotation.startSpeedVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} metadataOffset + */ +osrm.engine.api.fbresult.Annotation.addMetadata = function(builder, metadataOffset) { + builder.addFieldOffset(6, metadataOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Annotation.endAnnotation = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} distanceOffset + * @param {flatbuffers.Offset} durationOffset + * @param {flatbuffers.Offset} datasourcesOffset + * @param {flatbuffers.Offset} nodesOffset + * @param {flatbuffers.Offset} weightOffset + * @param {flatbuffers.Offset} speedOffset + * @param {flatbuffers.Offset} metadataOffset + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Annotation.createAnnotation = function(builder, distanceOffset, durationOffset, datasourcesOffset, nodesOffset, weightOffset, speedOffset, metadataOffset) { + osrm.engine.api.fbresult.Annotation.startAnnotation(builder); + osrm.engine.api.fbresult.Annotation.addDistance(builder, distanceOffset); + osrm.engine.api.fbresult.Annotation.addDuration(builder, durationOffset); + osrm.engine.api.fbresult.Annotation.addDatasources(builder, datasourcesOffset); + osrm.engine.api.fbresult.Annotation.addNodes(builder, nodesOffset); + osrm.engine.api.fbresult.Annotation.addWeight(builder, weightOffset); + osrm.engine.api.fbresult.Annotation.addSpeed(builder, speedOffset); + osrm.engine.api.fbresult.Annotation.addMetadata(builder, metadataOffset); + return osrm.engine.api.fbresult.Annotation.endAnnotation(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.StepManeuver = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.StepManeuver} + */ +osrm.engine.api.fbresult.StepManeuver.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.StepManeuver=} obj + * @returns {osrm.engine.api.fbresult.StepManeuver} + */ +osrm.engine.api.fbresult.StepManeuver.getRootAsStepManeuver = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.StepManeuver).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.StepManeuver=} obj + * @returns {osrm.engine.api.fbresult.StepManeuver} + */ +osrm.engine.api.fbresult.StepManeuver.getSizePrefixedRootAsStepManeuver = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.StepManeuver).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {osrm.engine.api.fbresult.Position=} obj + * @returns {osrm.engine.api.fbresult.Position|null} + */ +osrm.engine.api.fbresult.StepManeuver.prototype.location = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new osrm.engine.api.fbresult.Position).__init(this.bb_pos + offset, this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.StepManeuver.prototype.bearingBefore = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.StepManeuver.prototype.bearingAfter = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {osrm.engine.api.fbresult.ManeuverType} + */ +osrm.engine.api.fbresult.StepManeuver.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? /** @type {osrm.engine.api.fbresult.ManeuverType} */ (this.bb.readInt8(this.bb_pos + offset)) : osrm.engine.api.fbresult.ManeuverType.Turn; +}; + +/** + * @returns {osrm.engine.api.fbresult.Turn} + */ +osrm.engine.api.fbresult.StepManeuver.prototype.modifier = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? /** @type {osrm.engine.api.fbresult.Turn} */ (this.bb.readInt8(this.bb_pos + offset)) : osrm.engine.api.fbresult.Turn.None; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.StepManeuver.prototype.exit = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.StepManeuver.startStepManeuver = function(builder) { + builder.startObject(6); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} locationOffset + */ +osrm.engine.api.fbresult.StepManeuver.addLocation = function(builder, locationOffset) { + builder.addFieldStruct(0, locationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} bearingBefore + */ +osrm.engine.api.fbresult.StepManeuver.addBearingBefore = function(builder, bearingBefore) { + builder.addFieldInt16(1, bearingBefore, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} bearingAfter + */ +osrm.engine.api.fbresult.StepManeuver.addBearingAfter = function(builder, bearingAfter) { + builder.addFieldInt16(2, bearingAfter, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {osrm.engine.api.fbresult.ManeuverType} type + */ +osrm.engine.api.fbresult.StepManeuver.addType = function(builder, type) { + builder.addFieldInt8(3, type, osrm.engine.api.fbresult.ManeuverType.Turn); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {osrm.engine.api.fbresult.Turn} modifier + */ +osrm.engine.api.fbresult.StepManeuver.addModifier = function(builder, modifier) { + builder.addFieldInt8(4, modifier, osrm.engine.api.fbresult.Turn.None); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} exit + */ +osrm.engine.api.fbresult.StepManeuver.addExit = function(builder, exit) { + builder.addFieldInt8(5, exit, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.StepManeuver.endStepManeuver = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} locationOffset + * @param {number} bearingBefore + * @param {number} bearingAfter + * @param {osrm.engine.api.fbresult.ManeuverType} type + * @param {osrm.engine.api.fbresult.Turn} modifier + * @param {number} exit + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.StepManeuver.createStepManeuver = function(builder, locationOffset, bearingBefore, bearingAfter, type, modifier, exit) { + osrm.engine.api.fbresult.StepManeuver.startStepManeuver(builder); + osrm.engine.api.fbresult.StepManeuver.addLocation(builder, locationOffset); + osrm.engine.api.fbresult.StepManeuver.addBearingBefore(builder, bearingBefore); + osrm.engine.api.fbresult.StepManeuver.addBearingAfter(builder, bearingAfter); + osrm.engine.api.fbresult.StepManeuver.addType(builder, type); + osrm.engine.api.fbresult.StepManeuver.addModifier(builder, modifier); + osrm.engine.api.fbresult.StepManeuver.addExit(builder, exit); + return osrm.engine.api.fbresult.StepManeuver.endStepManeuver(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.Lane = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Lane} + */ +osrm.engine.api.fbresult.Lane.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Lane=} obj + * @returns {osrm.engine.api.fbresult.Lane} + */ +osrm.engine.api.fbresult.Lane.getRootAsLane = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Lane).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Lane=} obj + * @returns {osrm.engine.api.fbresult.Lane} + */ +osrm.engine.api.fbresult.Lane.getSizePrefixedRootAsLane = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Lane).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {number} index + * @returns {osrm.engine.api.fbresult.Turn} + */ +osrm.engine.api.fbresult.Lane.prototype.indications = function(index) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? /** @type {osrm.engine.api.fbresult.Turn} */ (this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index)) : /** @type {osrm.engine.api.fbresult.Turn} */ (0); +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Lane.prototype.indicationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Int8Array} + */ +osrm.engine.api.fbresult.Lane.prototype.indicationsArray = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {boolean} + */ +osrm.engine.api.fbresult.Lane.prototype.valid = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Lane.startLane = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} indicationsOffset + */ +osrm.engine.api.fbresult.Lane.addIndications = function(builder, indicationsOffset) { + builder.addFieldOffset(0, indicationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Lane.createIndicationsVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Lane.startIndicationsVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} valid + */ +osrm.engine.api.fbresult.Lane.addValid = function(builder, valid) { + builder.addFieldInt8(1, +valid, +false); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Lane.endLane = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} indicationsOffset + * @param {boolean} valid + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Lane.createLane = function(builder, indicationsOffset, valid) { + osrm.engine.api.fbresult.Lane.startLane(builder); + osrm.engine.api.fbresult.Lane.addIndications(builder, indicationsOffset); + osrm.engine.api.fbresult.Lane.addValid(builder, valid); + return osrm.engine.api.fbresult.Lane.endLane(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.Intersection = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Intersection} + */ +osrm.engine.api.fbresult.Intersection.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Intersection=} obj + * @returns {osrm.engine.api.fbresult.Intersection} + */ +osrm.engine.api.fbresult.Intersection.getRootAsIntersection = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Intersection).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Intersection=} obj + * @returns {osrm.engine.api.fbresult.Intersection} + */ +osrm.engine.api.fbresult.Intersection.getSizePrefixedRootAsIntersection = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Intersection).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {osrm.engine.api.fbresult.Position=} obj + * @returns {osrm.engine.api.fbresult.Position|null} + */ +osrm.engine.api.fbresult.Intersection.prototype.location = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new osrm.engine.api.fbresult.Position).__init(this.bb_pos + offset, this.bb) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Intersection.prototype.bearings = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt16(this.bb.__vector(this.bb_pos + offset) + index * 2) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Intersection.prototype.bearingsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Int16Array} + */ +osrm.engine.api.fbresult.Intersection.prototype.bearingsArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Int16Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array} + */ +osrm.engine.api.fbresult.Intersection.prototype.classes = function(index, optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Intersection.prototype.classesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {boolean} + */ +osrm.engine.api.fbresult.Intersection.prototype.entry = function(index) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Intersection.prototype.entryLength = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Int8Array} + */ +osrm.engine.api.fbresult.Intersection.prototype.entryArray = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Intersection.prototype.inBearing = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Intersection.prototype.outBearing = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.Lane=} obj + * @returns {osrm.engine.api.fbresult.Lane} + */ +osrm.engine.api.fbresult.Intersection.prototype.lanes = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? (obj || new osrm.engine.api.fbresult.Lane).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Intersection.prototype.lanesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Intersection.startIntersection = function(builder) { + builder.startObject(7); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} locationOffset + */ +osrm.engine.api.fbresult.Intersection.addLocation = function(builder, locationOffset) { + builder.addFieldStruct(0, locationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} bearingsOffset + */ +osrm.engine.api.fbresult.Intersection.addBearings = function(builder, bearingsOffset) { + builder.addFieldOffset(1, bearingsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Intersection.createBearingsVector = function(builder, data) { + builder.startVector(2, data.length, 2); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt16(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Intersection.startBearingsVector = function(builder, numElems) { + builder.startVector(2, numElems, 2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} classesOffset + */ +osrm.engine.api.fbresult.Intersection.addClasses = function(builder, classesOffset) { + builder.addFieldOffset(2, classesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Intersection.createClassesVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Intersection.startClassesVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} entryOffset + */ +osrm.engine.api.fbresult.Intersection.addEntry = function(builder, entryOffset) { + builder.addFieldOffset(3, entryOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Intersection.createEntryVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(+data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Intersection.startEntryVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} inBearing + */ +osrm.engine.api.fbresult.Intersection.addInBearing = function(builder, inBearing) { + builder.addFieldInt32(4, inBearing, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} outBearing + */ +osrm.engine.api.fbresult.Intersection.addOutBearing = function(builder, outBearing) { + builder.addFieldInt32(5, outBearing, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} lanesOffset + */ +osrm.engine.api.fbresult.Intersection.addLanes = function(builder, lanesOffset) { + builder.addFieldOffset(6, lanesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Intersection.createLanesVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Intersection.startLanesVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Intersection.endIntersection = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} locationOffset + * @param {flatbuffers.Offset} bearingsOffset + * @param {flatbuffers.Offset} classesOffset + * @param {flatbuffers.Offset} entryOffset + * @param {number} inBearing + * @param {number} outBearing + * @param {flatbuffers.Offset} lanesOffset + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Intersection.createIntersection = function(builder, locationOffset, bearingsOffset, classesOffset, entryOffset, inBearing, outBearing, lanesOffset) { + osrm.engine.api.fbresult.Intersection.startIntersection(builder); + osrm.engine.api.fbresult.Intersection.addLocation(builder, locationOffset); + osrm.engine.api.fbresult.Intersection.addBearings(builder, bearingsOffset); + osrm.engine.api.fbresult.Intersection.addClasses(builder, classesOffset); + osrm.engine.api.fbresult.Intersection.addEntry(builder, entryOffset); + osrm.engine.api.fbresult.Intersection.addInBearing(builder, inBearing); + osrm.engine.api.fbresult.Intersection.addOutBearing(builder, outBearing); + osrm.engine.api.fbresult.Intersection.addLanes(builder, lanesOffset); + return osrm.engine.api.fbresult.Intersection.endIntersection(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.Step = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Step} + */ +osrm.engine.api.fbresult.Step.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Step=} obj + * @returns {osrm.engine.api.fbresult.Step} + */ +osrm.engine.api.fbresult.Step.getRootAsStep = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Step).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Step=} obj + * @returns {osrm.engine.api.fbresult.Step} + */ +osrm.engine.api.fbresult.Step.getSizePrefixedRootAsStep = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Step).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Step.prototype.distance = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Step.prototype.duration = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.polyline = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.Position=} obj + * @returns {osrm.engine.api.fbresult.Position} + */ +osrm.engine.api.fbresult.Step.prototype.coordinates = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? (obj || new osrm.engine.api.fbresult.Position).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Step.prototype.coordinatesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Step.prototype.weight = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.name = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.ref = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.pronunciation = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.destinations = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.exits = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.mode = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {osrm.engine.api.fbresult.StepManeuver=} obj + * @returns {osrm.engine.api.fbresult.StepManeuver|null} + */ +osrm.engine.api.fbresult.Step.prototype.maneuver = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? (obj || new osrm.engine.api.fbresult.StepManeuver).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.Intersection=} obj + * @returns {osrm.engine.api.fbresult.Intersection} + */ +osrm.engine.api.fbresult.Step.prototype.intersections = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? (obj || new osrm.engine.api.fbresult.Intersection).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Step.prototype.intersectionsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.rotaryName = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Step.prototype.rotaryPronunciation = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 32); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @returns {boolean} + */ +osrm.engine.api.fbresult.Step.prototype.drivingSide = function() { + var offset = this.bb.__offset(this.bb_pos, 34); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Step.startStep = function(builder) { + builder.startObject(16); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} distance + */ +osrm.engine.api.fbresult.Step.addDistance = function(builder, distance) { + builder.addFieldFloat32(0, distance, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} duration + */ +osrm.engine.api.fbresult.Step.addDuration = function(builder, duration) { + builder.addFieldFloat32(1, duration, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} polylineOffset + */ +osrm.engine.api.fbresult.Step.addPolyline = function(builder, polylineOffset) { + builder.addFieldOffset(2, polylineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} coordinatesOffset + */ +osrm.engine.api.fbresult.Step.addCoordinates = function(builder, coordinatesOffset) { + builder.addFieldOffset(3, coordinatesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Step.startCoordinatesVector = function(builder, numElems) { + builder.startVector(8, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} weight + */ +osrm.engine.api.fbresult.Step.addWeight = function(builder, weight) { + builder.addFieldFloat32(4, weight, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} nameOffset + */ +osrm.engine.api.fbresult.Step.addName = function(builder, nameOffset) { + builder.addFieldOffset(5, nameOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} refOffset + */ +osrm.engine.api.fbresult.Step.addRef = function(builder, refOffset) { + builder.addFieldOffset(6, refOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} pronunciationOffset + */ +osrm.engine.api.fbresult.Step.addPronunciation = function(builder, pronunciationOffset) { + builder.addFieldOffset(7, pronunciationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} destinationsOffset + */ +osrm.engine.api.fbresult.Step.addDestinations = function(builder, destinationsOffset) { + builder.addFieldOffset(8, destinationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} exitsOffset + */ +osrm.engine.api.fbresult.Step.addExits = function(builder, exitsOffset) { + builder.addFieldOffset(9, exitsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modeOffset + */ +osrm.engine.api.fbresult.Step.addMode = function(builder, modeOffset) { + builder.addFieldOffset(10, modeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} maneuverOffset + */ +osrm.engine.api.fbresult.Step.addManeuver = function(builder, maneuverOffset) { + builder.addFieldOffset(11, maneuverOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} intersectionsOffset + */ +osrm.engine.api.fbresult.Step.addIntersections = function(builder, intersectionsOffset) { + builder.addFieldOffset(12, intersectionsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Step.createIntersectionsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Step.startIntersectionsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} rotaryNameOffset + */ +osrm.engine.api.fbresult.Step.addRotaryName = function(builder, rotaryNameOffset) { + builder.addFieldOffset(13, rotaryNameOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} rotaryPronunciationOffset + */ +osrm.engine.api.fbresult.Step.addRotaryPronunciation = function(builder, rotaryPronunciationOffset) { + builder.addFieldOffset(14, rotaryPronunciationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} drivingSide + */ +osrm.engine.api.fbresult.Step.addDrivingSide = function(builder, drivingSide) { + builder.addFieldInt8(15, +drivingSide, +false); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Step.endStep = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} distance + * @param {number} duration + * @param {flatbuffers.Offset} polylineOffset + * @param {flatbuffers.Offset} coordinatesOffset + * @param {number} weight + * @param {flatbuffers.Offset} nameOffset + * @param {flatbuffers.Offset} refOffset + * @param {flatbuffers.Offset} pronunciationOffset + * @param {flatbuffers.Offset} destinationsOffset + * @param {flatbuffers.Offset} exitsOffset + * @param {flatbuffers.Offset} modeOffset + * @param {flatbuffers.Offset} maneuverOffset + * @param {flatbuffers.Offset} intersectionsOffset + * @param {flatbuffers.Offset} rotaryNameOffset + * @param {flatbuffers.Offset} rotaryPronunciationOffset + * @param {boolean} drivingSide + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Step.createStep = function(builder, distance, duration, polylineOffset, coordinatesOffset, weight, nameOffset, refOffset, pronunciationOffset, destinationsOffset, exitsOffset, modeOffset, maneuverOffset, intersectionsOffset, rotaryNameOffset, rotaryPronunciationOffset, drivingSide) { + osrm.engine.api.fbresult.Step.startStep(builder); + osrm.engine.api.fbresult.Step.addDistance(builder, distance); + osrm.engine.api.fbresult.Step.addDuration(builder, duration); + osrm.engine.api.fbresult.Step.addPolyline(builder, polylineOffset); + osrm.engine.api.fbresult.Step.addCoordinates(builder, coordinatesOffset); + osrm.engine.api.fbresult.Step.addWeight(builder, weight); + osrm.engine.api.fbresult.Step.addName(builder, nameOffset); + osrm.engine.api.fbresult.Step.addRef(builder, refOffset); + osrm.engine.api.fbresult.Step.addPronunciation(builder, pronunciationOffset); + osrm.engine.api.fbresult.Step.addDestinations(builder, destinationsOffset); + osrm.engine.api.fbresult.Step.addExits(builder, exitsOffset); + osrm.engine.api.fbresult.Step.addMode(builder, modeOffset); + osrm.engine.api.fbresult.Step.addManeuver(builder, maneuverOffset); + osrm.engine.api.fbresult.Step.addIntersections(builder, intersectionsOffset); + osrm.engine.api.fbresult.Step.addRotaryName(builder, rotaryNameOffset); + osrm.engine.api.fbresult.Step.addRotaryPronunciation(builder, rotaryPronunciationOffset); + osrm.engine.api.fbresult.Step.addDrivingSide(builder, drivingSide); + return osrm.engine.api.fbresult.Step.endStep(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.Leg = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Leg} + */ +osrm.engine.api.fbresult.Leg.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Leg=} obj + * @returns {osrm.engine.api.fbresult.Leg} + */ +osrm.engine.api.fbresult.Leg.getRootAsLeg = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Leg).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Leg=} obj + * @returns {osrm.engine.api.fbresult.Leg} + */ +osrm.engine.api.fbresult.Leg.getSizePrefixedRootAsLeg = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Leg).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Leg.prototype.distance = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Leg.prototype.duration = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Leg.prototype.weight = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Leg.prototype.summary = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {osrm.engine.api.fbresult.Annotation=} obj + * @returns {osrm.engine.api.fbresult.Annotation|null} + */ +osrm.engine.api.fbresult.Leg.prototype.annotations = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? (obj || new osrm.engine.api.fbresult.Annotation).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.Step=} obj + * @returns {osrm.engine.api.fbresult.Step} + */ +osrm.engine.api.fbresult.Leg.prototype.steps = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? (obj || new osrm.engine.api.fbresult.Step).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Leg.prototype.stepsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Leg.startLeg = function(builder) { + builder.startObject(6); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} distance + */ +osrm.engine.api.fbresult.Leg.addDistance = function(builder, distance) { + builder.addFieldFloat64(0, distance, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} duration + */ +osrm.engine.api.fbresult.Leg.addDuration = function(builder, duration) { + builder.addFieldFloat64(1, duration, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} weight + */ +osrm.engine.api.fbresult.Leg.addWeight = function(builder, weight) { + builder.addFieldFloat64(2, weight, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} summaryOffset + */ +osrm.engine.api.fbresult.Leg.addSummary = function(builder, summaryOffset) { + builder.addFieldOffset(3, summaryOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} annotationsOffset + */ +osrm.engine.api.fbresult.Leg.addAnnotations = function(builder, annotationsOffset) { + builder.addFieldOffset(4, annotationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} stepsOffset + */ +osrm.engine.api.fbresult.Leg.addSteps = function(builder, stepsOffset) { + builder.addFieldOffset(5, stepsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Leg.createStepsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Leg.startStepsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Leg.endLeg = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} distance + * @param {number} duration + * @param {number} weight + * @param {flatbuffers.Offset} summaryOffset + * @param {flatbuffers.Offset} annotationsOffset + * @param {flatbuffers.Offset} stepsOffset + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Leg.createLeg = function(builder, distance, duration, weight, summaryOffset, annotationsOffset, stepsOffset) { + osrm.engine.api.fbresult.Leg.startLeg(builder); + osrm.engine.api.fbresult.Leg.addDistance(builder, distance); + osrm.engine.api.fbresult.Leg.addDuration(builder, duration); + osrm.engine.api.fbresult.Leg.addWeight(builder, weight); + osrm.engine.api.fbresult.Leg.addSummary(builder, summaryOffset); + osrm.engine.api.fbresult.Leg.addAnnotations(builder, annotationsOffset); + osrm.engine.api.fbresult.Leg.addSteps(builder, stepsOffset); + return osrm.engine.api.fbresult.Leg.endLeg(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.RouteObject = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.RouteObject} + */ +osrm.engine.api.fbresult.RouteObject.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.RouteObject=} obj + * @returns {osrm.engine.api.fbresult.RouteObject} + */ +osrm.engine.api.fbresult.RouteObject.getRootAsRouteObject = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.RouteObject).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.RouteObject=} obj + * @returns {osrm.engine.api.fbresult.RouteObject} + */ +osrm.engine.api.fbresult.RouteObject.getSizePrefixedRootAsRouteObject = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.RouteObject).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.RouteObject.prototype.distance = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.RouteObject.prototype.duration = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.RouteObject.prototype.weight = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.RouteObject.prototype.weightName = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.RouteObject.prototype.confidence = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.RouteObject.prototype.polyline = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.Position=} obj + * @returns {osrm.engine.api.fbresult.Position} + */ +osrm.engine.api.fbresult.RouteObject.prototype.coordinates = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? (obj || new osrm.engine.api.fbresult.Position).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.RouteObject.prototype.coordinatesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.Leg=} obj + * @returns {osrm.engine.api.fbresult.Leg} + */ +osrm.engine.api.fbresult.RouteObject.prototype.legs = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? (obj || new osrm.engine.api.fbresult.Leg).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.RouteObject.prototype.legsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.RouteObject.startRouteObject = function(builder) { + builder.startObject(8); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} distance + */ +osrm.engine.api.fbresult.RouteObject.addDistance = function(builder, distance) { + builder.addFieldFloat32(0, distance, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} duration + */ +osrm.engine.api.fbresult.RouteObject.addDuration = function(builder, duration) { + builder.addFieldFloat32(1, duration, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} weight + */ +osrm.engine.api.fbresult.RouteObject.addWeight = function(builder, weight) { + builder.addFieldFloat32(2, weight, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} weightNameOffset + */ +osrm.engine.api.fbresult.RouteObject.addWeightName = function(builder, weightNameOffset) { + builder.addFieldOffset(3, weightNameOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} confidence + */ +osrm.engine.api.fbresult.RouteObject.addConfidence = function(builder, confidence) { + builder.addFieldFloat32(4, confidence, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} polylineOffset + */ +osrm.engine.api.fbresult.RouteObject.addPolyline = function(builder, polylineOffset) { + builder.addFieldOffset(5, polylineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} coordinatesOffset + */ +osrm.engine.api.fbresult.RouteObject.addCoordinates = function(builder, coordinatesOffset) { + builder.addFieldOffset(6, coordinatesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.RouteObject.startCoordinatesVector = function(builder, numElems) { + builder.startVector(8, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} legsOffset + */ +osrm.engine.api.fbresult.RouteObject.addLegs = function(builder, legsOffset) { + builder.addFieldOffset(7, legsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.RouteObject.createLegsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.RouteObject.startLegsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.RouteObject.endRouteObject = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} distance + * @param {number} duration + * @param {number} weight + * @param {flatbuffers.Offset} weightNameOffset + * @param {number} confidence + * @param {flatbuffers.Offset} polylineOffset + * @param {flatbuffers.Offset} coordinatesOffset + * @param {flatbuffers.Offset} legsOffset + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.RouteObject.createRouteObject = function(builder, distance, duration, weight, weightNameOffset, confidence, polylineOffset, coordinatesOffset, legsOffset) { + osrm.engine.api.fbresult.RouteObject.startRouteObject(builder); + osrm.engine.api.fbresult.RouteObject.addDistance(builder, distance); + osrm.engine.api.fbresult.RouteObject.addDuration(builder, duration); + osrm.engine.api.fbresult.RouteObject.addWeight(builder, weight); + osrm.engine.api.fbresult.RouteObject.addWeightName(builder, weightNameOffset); + osrm.engine.api.fbresult.RouteObject.addConfidence(builder, confidence); + osrm.engine.api.fbresult.RouteObject.addPolyline(builder, polylineOffset); + osrm.engine.api.fbresult.RouteObject.addCoordinates(builder, coordinatesOffset); + osrm.engine.api.fbresult.RouteObject.addLegs(builder, legsOffset); + return osrm.engine.api.fbresult.RouteObject.endRouteObject(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.Table = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Table} + */ +osrm.engine.api.fbresult.Table.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Table=} obj + * @returns {osrm.engine.api.fbresult.Table} + */ +osrm.engine.api.fbresult.Table.getRootAsTable = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Table).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Table=} obj + * @returns {osrm.engine.api.fbresult.Table} + */ +osrm.engine.api.fbresult.Table.getSizePrefixedRootAsTable = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Table).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.durations = function(index) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.durationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Float32Array} + */ +osrm.engine.api.fbresult.Table.prototype.durationsArray = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.rows = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.cols = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.distances = function(index) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.distancesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Float32Array} + */ +osrm.engine.api.fbresult.Table.prototype.distancesArray = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.Waypoint=} obj + * @returns {osrm.engine.api.fbresult.Waypoint} + */ +osrm.engine.api.fbresult.Table.prototype.destinations = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? (obj || new osrm.engine.api.fbresult.Waypoint).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.destinationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.fallbackSpeedCells = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.Table.prototype.fallbackSpeedCellsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +osrm.engine.api.fbresult.Table.prototype.fallbackSpeedCellsArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Table.startTable = function(builder) { + builder.startObject(6); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationsOffset + */ +osrm.engine.api.fbresult.Table.addDurations = function(builder, durationsOffset) { + builder.addFieldOffset(0, durationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Table.createDurationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addFloat32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Table.startDurationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} rows + */ +osrm.engine.api.fbresult.Table.addRows = function(builder, rows) { + builder.addFieldInt16(1, rows, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} cols + */ +osrm.engine.api.fbresult.Table.addCols = function(builder, cols) { + builder.addFieldInt16(2, cols, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} distancesOffset + */ +osrm.engine.api.fbresult.Table.addDistances = function(builder, distancesOffset) { + builder.addFieldOffset(3, distancesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Table.createDistancesVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addFloat32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Table.startDistancesVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} destinationsOffset + */ +osrm.engine.api.fbresult.Table.addDestinations = function(builder, destinationsOffset) { + builder.addFieldOffset(4, destinationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Table.createDestinationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Table.startDestinationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} fallbackSpeedCellsOffset + */ +osrm.engine.api.fbresult.Table.addFallbackSpeedCells = function(builder, fallbackSpeedCellsOffset) { + builder.addFieldOffset(5, fallbackSpeedCellsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Table.createFallbackSpeedCellsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.Table.startFallbackSpeedCellsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Table.endTable = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationsOffset + * @param {number} rows + * @param {number} cols + * @param {flatbuffers.Offset} distancesOffset + * @param {flatbuffers.Offset} destinationsOffset + * @param {flatbuffers.Offset} fallbackSpeedCellsOffset + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Table.createTable = function(builder, durationsOffset, rows, cols, distancesOffset, destinationsOffset, fallbackSpeedCellsOffset) { + osrm.engine.api.fbresult.Table.startTable(builder); + osrm.engine.api.fbresult.Table.addDurations(builder, durationsOffset); + osrm.engine.api.fbresult.Table.addRows(builder, rows); + osrm.engine.api.fbresult.Table.addCols(builder, cols); + osrm.engine.api.fbresult.Table.addDistances(builder, distancesOffset); + osrm.engine.api.fbresult.Table.addDestinations(builder, destinationsOffset); + osrm.engine.api.fbresult.Table.addFallbackSpeedCells(builder, fallbackSpeedCellsOffset); + return osrm.engine.api.fbresult.Table.endTable(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.Error = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.Error} + */ +osrm.engine.api.fbresult.Error.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Error=} obj + * @returns {osrm.engine.api.fbresult.Error} + */ +osrm.engine.api.fbresult.Error.getRootAsError = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Error).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.Error=} obj + * @returns {osrm.engine.api.fbresult.Error} + */ +osrm.engine.api.fbresult.Error.getSizePrefixedRootAsError = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.Error).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Error.prototype.code = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.Error.prototype.message = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.Error.startError = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} codeOffset + */ +osrm.engine.api.fbresult.Error.addCode = function(builder, codeOffset) { + builder.addFieldOffset(0, codeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} messageOffset + */ +osrm.engine.api.fbresult.Error.addMessage = function(builder, messageOffset) { + builder.addFieldOffset(1, messageOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Error.endError = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} codeOffset + * @param {flatbuffers.Offset} messageOffset + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.Error.createError = function(builder, codeOffset, messageOffset) { + osrm.engine.api.fbresult.Error.startError(builder); + osrm.engine.api.fbresult.Error.addCode(builder, codeOffset); + osrm.engine.api.fbresult.Error.addMessage(builder, messageOffset); + return osrm.engine.api.fbresult.Error.endError(builder); +} + +/** + * @constructor + */ +osrm.engine.api.fbresult.FBResult = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {osrm.engine.api.fbresult.FBResult} + */ +osrm.engine.api.fbresult.FBResult.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.FBResult=} obj + * @returns {osrm.engine.api.fbresult.FBResult} + */ +osrm.engine.api.fbresult.FBResult.getRootAsFBResult = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.FBResult).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {osrm.engine.api.fbresult.FBResult=} obj + * @returns {osrm.engine.api.fbresult.FBResult} + */ +osrm.engine.api.fbresult.FBResult.getSizePrefixedRootAsFBResult = function(bb, obj) { + return (obj || new osrm.engine.api.fbresult.FBResult).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {boolean} + */ +osrm.engine.api.fbresult.FBResult.prototype.error = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; +}; + +/** + * @param {osrm.engine.api.fbresult.Error=} obj + * @returns {osrm.engine.api.fbresult.Error|null} + */ +osrm.engine.api.fbresult.FBResult.prototype.code = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? (obj || new osrm.engine.api.fbresult.Error).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +osrm.engine.api.fbresult.FBResult.prototype.dataVersion = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.Waypoint=} obj + * @returns {osrm.engine.api.fbresult.Waypoint} + */ +osrm.engine.api.fbresult.FBResult.prototype.waypoints = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? (obj || new osrm.engine.api.fbresult.Waypoint).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.FBResult.prototype.waypointsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {osrm.engine.api.fbresult.RouteObject=} obj + * @returns {osrm.engine.api.fbresult.RouteObject} + */ +osrm.engine.api.fbresult.FBResult.prototype.routes = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? (obj || new osrm.engine.api.fbresult.RouteObject).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +osrm.engine.api.fbresult.FBResult.prototype.routesLength = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {osrm.engine.api.fbresult.Table=} obj + * @returns {osrm.engine.api.fbresult.Table|null} + */ +osrm.engine.api.fbresult.FBResult.prototype.table = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? (obj || new osrm.engine.api.fbresult.Table).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +osrm.engine.api.fbresult.FBResult.startFBResult = function(builder) { + builder.startObject(6); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} error + */ +osrm.engine.api.fbresult.FBResult.addError = function(builder, error) { + builder.addFieldInt8(0, +error, +false); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} codeOffset + */ +osrm.engine.api.fbresult.FBResult.addCode = function(builder, codeOffset) { + builder.addFieldOffset(1, codeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} dataVersionOffset + */ +osrm.engine.api.fbresult.FBResult.addDataVersion = function(builder, dataVersionOffset) { + builder.addFieldOffset(2, dataVersionOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} waypointsOffset + */ +osrm.engine.api.fbresult.FBResult.addWaypoints = function(builder, waypointsOffset) { + builder.addFieldOffset(3, waypointsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.FBResult.createWaypointsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.FBResult.startWaypointsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} routesOffset + */ +osrm.engine.api.fbresult.FBResult.addRoutes = function(builder, routesOffset) { + builder.addFieldOffset(4, routesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.FBResult.createRoutesVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +osrm.engine.api.fbresult.FBResult.startRoutesVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} tableOffset + */ +osrm.engine.api.fbresult.FBResult.addTable = function(builder, tableOffset) { + builder.addFieldOffset(5, tableOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.FBResult.endFBResult = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +osrm.engine.api.fbresult.FBResult.finishFBResultBuffer = function(builder, offset) { + builder.finish(offset); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +osrm.engine.api.fbresult.FBResult.finishSizePrefixedFBResultBuffer = function(builder, offset) { + builder.finish(offset, undefined, true); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {boolean} error + * @param {flatbuffers.Offset} codeOffset + * @param {flatbuffers.Offset} dataVersionOffset + * @param {flatbuffers.Offset} waypointsOffset + * @param {flatbuffers.Offset} routesOffset + * @param {flatbuffers.Offset} tableOffset + * @returns {flatbuffers.Offset} + */ +osrm.engine.api.fbresult.FBResult.createFBResult = function(builder, error, codeOffset, dataVersionOffset, waypointsOffset, routesOffset, tableOffset) { + osrm.engine.api.fbresult.FBResult.startFBResult(builder); + osrm.engine.api.fbresult.FBResult.addError(builder, error); + osrm.engine.api.fbresult.FBResult.addCode(builder, codeOffset); + osrm.engine.api.fbresult.FBResult.addDataVersion(builder, dataVersionOffset); + osrm.engine.api.fbresult.FBResult.addWaypoints(builder, waypointsOffset); + osrm.engine.api.fbresult.FBResult.addRoutes(builder, routesOffset); + osrm.engine.api.fbresult.FBResult.addTable(builder, tableOffset); + return osrm.engine.api.fbresult.FBResult.endFBResult(builder); +} + +// Exports for Node.js and RequireJS +this.osrm = osrm; diff --git a/features/support/flatbuffers.js b/features/support/flatbuffers.js new file mode 100644 index 000000000..461cd7af8 --- /dev/null +++ b/features/support/flatbuffers.js @@ -0,0 +1,1259 @@ +/// @file +/// @addtogroup flatbuffers_javascript_api +/// @{ +/// @cond FLATBUFFERS_INTERNAL + +/** + * @fileoverview + * + * Need to suppress 'global this' error so the Node.js export line doesn't cause + * closure compile to error out. + * @suppress {globalThis} + */ + +/** + * @const + * @namespace + */ +var flatbuffers = {}; + +/** + * @typedef {number} + */ +flatbuffers.Offset; + +/** + * @typedef {{ + * bb: flatbuffers.ByteBuffer, + * bb_pos: number + * }} + */ +flatbuffers.Table; + +/** + * @type {number} + * @const + */ +flatbuffers.SIZEOF_SHORT = 2; + +/** + * @type {number} + * @const + */ +flatbuffers.SIZEOF_INT = 4; + +/** + * @type {number} + * @const + */ +flatbuffers.FILE_IDENTIFIER_LENGTH = 4; + +/** + * @type {number} + * @const + */ +flatbuffers.SIZE_PREFIX_LENGTH = 4; + +/** + * @enum {number} + */ +flatbuffers.Encoding = { + UTF8_BYTES: 1, + UTF16_STRING: 2 +}; + +/** + * @type {Int32Array} + * @const + */ +flatbuffers.int32 = new Int32Array(2); + +/** + * @type {Float32Array} + * @const + */ +flatbuffers.float32 = new Float32Array(flatbuffers.int32.buffer); + +/** + * @type {Float64Array} + * @const + */ +flatbuffers.float64 = new Float64Array(flatbuffers.int32.buffer); + +/** + * @type {boolean} + * @const + */ +flatbuffers.isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1; + +//////////////////////////////////////////////////////////////////////////////// + +/** + * @constructor + * @param {number} low + * @param {number} high + */ +flatbuffers.Long = function(low, high) { + /** + * @type {number} + * @const + */ + this.low = low | 0; + + /** + * @type {number} + * @const + */ + this.high = high | 0; +}; + +/** + * @param {number} low + * @param {number} high + * @returns {flatbuffers.Long} + */ +flatbuffers.Long.create = function(low, high) { + // Special-case zero to avoid GC overhead for default values + return low == 0 && high == 0 ? flatbuffers.Long.ZERO : new flatbuffers.Long(low, high); +}; + +/** + * @returns {number} + */ +flatbuffers.Long.prototype.toFloat64 = function() { + return (this.low >>> 0) + this.high * 0x100000000; +}; + +/** + * @param {flatbuffers.Long} other + * @returns {boolean} + */ +flatbuffers.Long.prototype.equals = function(other) { + return this.low == other.low && this.high == other.high; +}; + +/** + * @type {flatbuffers.Long} + * @const + */ +flatbuffers.Long.ZERO = new flatbuffers.Long(0, 0); + +/// @endcond +//////////////////////////////////////////////////////////////////////////////// +/** + * Create a FlatBufferBuilder. + * + * @constructor + * @param {number=} opt_initial_size + */ +flatbuffers.Builder = function(opt_initial_size) { + if (!opt_initial_size) { + var initial_size = 1024; + } else { + var initial_size = opt_initial_size; + } + + /** + * @type {flatbuffers.ByteBuffer} + * @private + */ + this.bb = flatbuffers.ByteBuffer.allocate(initial_size); + + /** + * Remaining space in the ByteBuffer. + * + * @type {number} + * @private + */ + this.space = initial_size; + + /** + * Minimum alignment encountered so far. + * + * @type {number} + * @private + */ + this.minalign = 1; + + /** + * The vtable for the current table. + * + * @type {Array.} + * @private + */ + this.vtable = null; + + /** + * The amount of fields we're actually using. + * + * @type {number} + * @private + */ + this.vtable_in_use = 0; + + /** + * Whether we are currently serializing a table. + * + * @type {boolean} + * @private + */ + this.isNested = false; + + /** + * Starting offset of the current struct/table. + * + * @type {number} + * @private + */ + this.object_start = 0; + + /** + * List of offsets of all vtables. + * + * @type {Array.} + * @private + */ + this.vtables = []; + + /** + * For the current vector being built. + * + * @type {number} + * @private + */ + this.vector_num_elems = 0; + + /** + * False omits default values from the serialized data + * + * @type {boolean} + * @private + */ + this.force_defaults = false; +}; + +flatbuffers.Builder.prototype.clear = function() { + this.bb.clear(); + this.space = this.bb.capacity(); + this.minalign = 1; + this.vtable = null; + this.vtable_in_use = 0; + this.isNested = false; + this.object_start = 0; + this.vtables = []; + this.vector_num_elems = 0; + this.force_defaults = false; +}; + +/** + * In order to save space, fields that are set to their default value + * don't get serialized into the buffer. Forcing defaults provides a + * way to manually disable this optimization. + * + * @param {boolean} forceDefaults true always serializes default values + */ +flatbuffers.Builder.prototype.forceDefaults = function(forceDefaults) { + this.force_defaults = forceDefaults; +}; + +/** + * Get the ByteBuffer representing the FlatBuffer. Only call this after you've + * called finish(). The actual data starts at the ByteBuffer's current position, + * not necessarily at 0. + * + * @returns {flatbuffers.ByteBuffer} + */ +flatbuffers.Builder.prototype.dataBuffer = function() { + return this.bb; +}; + +/** + * Get the bytes representing the FlatBuffer. Only call this after you've + * called finish(). + * + * @returns {Uint8Array} + */ +flatbuffers.Builder.prototype.asUint8Array = function() { + return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset()); +}; + +/// @cond FLATBUFFERS_INTERNAL +/** + * Prepare to write an element of `size` after `additional_bytes` have been + * written, e.g. if you write a string, you need to align such the int length + * field is aligned to 4 bytes, and the string data follows it directly. If all + * you need to do is alignment, `additional_bytes` will be 0. + * + * @param {number} size This is the of the new element to write + * @param {number} additional_bytes The padding size + */ +flatbuffers.Builder.prototype.prep = function(size, additional_bytes) { + // Track the biggest thing we've ever aligned to. + if (size > this.minalign) { + this.minalign = size; + } + + // Find the amount of alignment needed such that `size` is properly + // aligned after `additional_bytes` + var align_size = ((~(this.bb.capacity() - this.space + additional_bytes)) + 1) & (size - 1); + + // Reallocate the buffer if needed. + while (this.space < align_size + size + additional_bytes) { + var old_buf_size = this.bb.capacity(); + this.bb = flatbuffers.Builder.growByteBuffer(this.bb); + this.space += this.bb.capacity() - old_buf_size; + } + + this.pad(align_size); +}; + +/** + * @param {number} byte_size + */ +flatbuffers.Builder.prototype.pad = function(byte_size) { + for (var i = 0; i < byte_size; i++) { + this.bb.writeInt8(--this.space, 0); + } +}; + +/** + * @param {number} value + */ +flatbuffers.Builder.prototype.writeInt8 = function(value) { + this.bb.writeInt8(this.space -= 1, value); +}; + +/** + * @param {number} value + */ +flatbuffers.Builder.prototype.writeInt16 = function(value) { + this.bb.writeInt16(this.space -= 2, value); +}; + +/** + * @param {number} value + */ +flatbuffers.Builder.prototype.writeInt32 = function(value) { + this.bb.writeInt32(this.space -= 4, value); +}; + +/** + * @param {flatbuffers.Long} value + */ +flatbuffers.Builder.prototype.writeInt64 = function(value) { + this.bb.writeInt64(this.space -= 8, value); +}; + +/** + * @param {number} value + */ +flatbuffers.Builder.prototype.writeFloat32 = function(value) { + this.bb.writeFloat32(this.space -= 4, value); +}; + +/** + * @param {number} value + */ +flatbuffers.Builder.prototype.writeFloat64 = function(value) { + this.bb.writeFloat64(this.space -= 8, value); +}; +/// @endcond + +/** + * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param {number} value The `int8` to add the the buffer. + */ +flatbuffers.Builder.prototype.addInt8 = function(value) { + this.prep(1, 0); + this.writeInt8(value); +}; + +/** + * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param {number} value The `int16` to add the the buffer. + */ +flatbuffers.Builder.prototype.addInt16 = function(value) { + this.prep(2, 0); + this.writeInt16(value); +}; + +/** + * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param {number} value The `int32` to add the the buffer. + */ +flatbuffers.Builder.prototype.addInt32 = function(value) { + this.prep(4, 0); + this.writeInt32(value); +}; + +/** + * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param {flatbuffers.Long} value The `int64` to add the the buffer. + */ +flatbuffers.Builder.prototype.addInt64 = function(value) { + this.prep(8, 0); + this.writeInt64(value); +}; + +/** + * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param {number} value The `float32` to add the the buffer. + */ +flatbuffers.Builder.prototype.addFloat32 = function(value) { + this.prep(4, 0); + this.writeFloat32(value); +}; + +/** + * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary). + * @param {number} value The `float64` to add the the buffer. + */ +flatbuffers.Builder.prototype.addFloat64 = function(value) { + this.prep(8, 0); + this.writeFloat64(value); +}; + +/// @cond FLATBUFFERS_INTERNAL +/** + * @param {number} voffset + * @param {number} value + * @param {number} defaultValue + */ +flatbuffers.Builder.prototype.addFieldInt8 = function(voffset, value, defaultValue) { + if (this.force_defaults || value != defaultValue) { + this.addInt8(value); + this.slot(voffset); + } +}; + +/** + * @param {number} voffset + * @param {number} value + * @param {number} defaultValue + */ +flatbuffers.Builder.prototype.addFieldInt16 = function(voffset, value, defaultValue) { + if (this.force_defaults || value != defaultValue) { + this.addInt16(value); + this.slot(voffset); + } +}; + +/** + * @param {number} voffset + * @param {number} value + * @param {number} defaultValue + */ +flatbuffers.Builder.prototype.addFieldInt32 = function(voffset, value, defaultValue) { + if (this.force_defaults || value != defaultValue) { + this.addInt32(value); + this.slot(voffset); + } +}; + +/** + * @param {number} voffset + * @param {flatbuffers.Long} value + * @param {flatbuffers.Long} defaultValue + */ +flatbuffers.Builder.prototype.addFieldInt64 = function(voffset, value, defaultValue) { + if (this.force_defaults || !value.equals(defaultValue)) { + this.addInt64(value); + this.slot(voffset); + } +}; + +/** + * @param {number} voffset + * @param {number} value + * @param {number} defaultValue + */ +flatbuffers.Builder.prototype.addFieldFloat32 = function(voffset, value, defaultValue) { + if (this.force_defaults || value != defaultValue) { + this.addFloat32(value); + this.slot(voffset); + } +}; + +/** + * @param {number} voffset + * @param {number} value + * @param {number} defaultValue + */ +flatbuffers.Builder.prototype.addFieldFloat64 = function(voffset, value, defaultValue) { + if (this.force_defaults || value != defaultValue) { + this.addFloat64(value); + this.slot(voffset); + } +}; + +/** + * @param {number} voffset + * @param {flatbuffers.Offset} value + * @param {flatbuffers.Offset} defaultValue + */ +flatbuffers.Builder.prototype.addFieldOffset = function(voffset, value, defaultValue) { + if (this.force_defaults || value != defaultValue) { + this.addOffset(value); + this.slot(voffset); + } +}; + +/** + * Structs are stored inline, so nothing additional is being added. `d` is always 0. + * + * @param {number} voffset + * @param {flatbuffers.Offset} value + * @param {flatbuffers.Offset} defaultValue + */ +flatbuffers.Builder.prototype.addFieldStruct = function(voffset, value, defaultValue) { + if (value != defaultValue) { + this.nested(value); + this.slot(voffset); + } +}; + +/** + * Structures are always stored inline, they need to be created right + * where they're used. You'll get this assertion failure if you + * created it elsewhere. + * + * @param {flatbuffers.Offset} obj The offset of the created object + */ +flatbuffers.Builder.prototype.nested = function(obj) { + if (obj != this.offset()) { + throw new Error('FlatBuffers: struct must be serialized inline.'); + } +}; + +/** + * Should not be creating any other object, string or vector + * while an object is being constructed + */ +flatbuffers.Builder.prototype.notNested = function() { + if (this.isNested) { + throw new Error('FlatBuffers: object serialization must not be nested.'); + } +}; + +/** + * Set the current vtable at `voffset` to the current location in the buffer. + * + * @param {number} voffset + */ +flatbuffers.Builder.prototype.slot = function(voffset) { + this.vtable[voffset] = this.offset(); +}; + +/** + * @returns {flatbuffers.Offset} Offset relative to the end of the buffer. + */ +flatbuffers.Builder.prototype.offset = function() { + return this.bb.capacity() - this.space; +}; + +/** + * Doubles the size of the backing ByteBuffer and copies the old data towards + * the end of the new buffer (since we build the buffer backwards). + * + * @param {flatbuffers.ByteBuffer} bb The current buffer with the existing data + * @returns {flatbuffers.ByteBuffer} A new byte buffer with the old data copied + * to it. The data is located at the end of the buffer. + * + * uint8Array.set() formally takes {Array|ArrayBufferView}, so to pass + * it a uint8Array we need to suppress the type check: + * @suppress {checkTypes} + */ +flatbuffers.Builder.growByteBuffer = function(bb) { + var old_buf_size = bb.capacity(); + + // Ensure we don't grow beyond what fits in an int. + if (old_buf_size & 0xC0000000) { + throw new Error('FlatBuffers: cannot grow buffer beyond 2 gigabytes.'); + } + + var new_buf_size = old_buf_size << 1; + var nbb = flatbuffers.ByteBuffer.allocate(new_buf_size); + nbb.setPosition(new_buf_size - old_buf_size); + nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size); + return nbb; +}; +/// @endcond + +/** + * Adds on offset, relative to where it will be written. + * + * @param {flatbuffers.Offset} offset The offset to add. + */ +flatbuffers.Builder.prototype.addOffset = function(offset) { + this.prep(flatbuffers.SIZEOF_INT, 0); // Ensure alignment is already done. + this.writeInt32(this.offset() - offset + flatbuffers.SIZEOF_INT); +}; + +/// @cond FLATBUFFERS_INTERNAL +/** + * Start encoding a new object in the buffer. Users will not usually need to + * call this directly. The FlatBuffers compiler will generate helper methods + * that call this method internally. + * + * @param {number} numfields + */ +flatbuffers.Builder.prototype.startObject = function(numfields) { + this.notNested(); + if (this.vtable == null) { + this.vtable = []; + } + this.vtable_in_use = numfields; + for (var i = 0; i < numfields; i++) { + this.vtable[i] = 0; // This will push additional elements as needed + } + this.isNested = true; + this.object_start = this.offset(); +}; + +/** + * Finish off writing the object that is under construction. + * + * @returns {flatbuffers.Offset} The offset to the object inside `dataBuffer` + */ +flatbuffers.Builder.prototype.endObject = function() { + if (this.vtable == null || !this.isNested) { + throw new Error('FlatBuffers: endObject called without startObject'); + } + + this.addInt32(0); + var vtableloc = this.offset(); + + // Trim trailing zeroes. + var i = this.vtable_in_use - 1; + for (; i >= 0 && this.vtable[i] == 0; i--) {} + var trimmed_size = i + 1; + + // Write out the current vtable. + for (; i >= 0; i--) { + // Offset relative to the start of the table. + this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0); + } + + var standard_fields = 2; // The fields below: + this.addInt16(vtableloc - this.object_start); + var len = (trimmed_size + standard_fields) * flatbuffers.SIZEOF_SHORT; + this.addInt16(len); + + // Search for an existing vtable that matches the current one. + var existing_vtable = 0; + var vt1 = this.space; +outer_loop: + for (i = 0; i < this.vtables.length; i++) { + var vt2 = this.bb.capacity() - this.vtables[i]; + if (len == this.bb.readInt16(vt2)) { + for (var j = flatbuffers.SIZEOF_SHORT; j < len; j += flatbuffers.SIZEOF_SHORT) { + if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) { + continue outer_loop; + } + } + existing_vtable = this.vtables[i]; + break; + } + } + + if (existing_vtable) { + // Found a match: + // Remove the current vtable. + this.space = this.bb.capacity() - vtableloc; + + // Point table to existing vtable. + this.bb.writeInt32(this.space, existing_vtable - vtableloc); + } else { + // No match: + // Add the location of the current vtable to the list of vtables. + this.vtables.push(this.offset()); + + // Point table to current vtable. + this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc); + } + + this.isNested = false; + return vtableloc; +}; +/// @endcond + +/** + * Finalize a buffer, poiting to the given `root_table`. + * + * @param {flatbuffers.Offset} root_table + * @param {string=} opt_file_identifier + * @param {boolean=} opt_size_prefix + */ +flatbuffers.Builder.prototype.finish = function(root_table, opt_file_identifier, opt_size_prefix) { + var size_prefix = opt_size_prefix ? flatbuffers.SIZE_PREFIX_LENGTH : 0; + if (opt_file_identifier) { + var file_identifier = opt_file_identifier; + this.prep(this.minalign, flatbuffers.SIZEOF_INT + + flatbuffers.FILE_IDENTIFIER_LENGTH + size_prefix); + if (file_identifier.length != flatbuffers.FILE_IDENTIFIER_LENGTH) { + throw new Error('FlatBuffers: file identifier must be length ' + + flatbuffers.FILE_IDENTIFIER_LENGTH); + } + for (var i = flatbuffers.FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) { + this.writeInt8(file_identifier.charCodeAt(i)); + } + } + this.prep(this.minalign, flatbuffers.SIZEOF_INT + size_prefix); + this.addOffset(root_table); + if (size_prefix) { + this.addInt32(this.bb.capacity() - this.space); + } + this.bb.setPosition(this.space); +}; + +/** + * Finalize a size prefixed buffer, pointing to the given `root_table`. + * + * @param {flatbuffers.Offset} root_table + * @param {string=} opt_file_identifier + */ +flatbuffers.Builder.prototype.finishSizePrefixed = function (root_table, opt_file_identifier) { + this.finish(root_table, opt_file_identifier, true); +}; + +/// @cond FLATBUFFERS_INTERNAL +/** + * This checks a required field has been set in a given table that has + * just been constructed. + * + * @param {flatbuffers.Offset} table + * @param {number} field + */ +flatbuffers.Builder.prototype.requiredField = function(table, field) { + var table_start = this.bb.capacity() - table; + var vtable_start = table_start - this.bb.readInt32(table_start); + var ok = this.bb.readInt16(vtable_start + field) != 0; + + // If this fails, the caller will show what field needs to be set. + if (!ok) { + throw new Error('FlatBuffers: field ' + field + ' must be set'); + } +}; + +/** + * Start a new array/vector of objects. Users usually will not call + * this directly. The FlatBuffers compiler will create a start/end + * method for vector types in generated code. + * + * @param {number} elem_size The size of each element in the array + * @param {number} num_elems The number of elements in the array + * @param {number} alignment The alignment of the array + */ +flatbuffers.Builder.prototype.startVector = function(elem_size, num_elems, alignment) { + this.notNested(); + this.vector_num_elems = num_elems; + this.prep(flatbuffers.SIZEOF_INT, elem_size * num_elems); + this.prep(alignment, elem_size * num_elems); // Just in case alignment > int. +}; + +/** + * Finish off the creation of an array and all its elements. The array must be + * created with `startVector`. + * + * @returns {flatbuffers.Offset} The offset at which the newly created array + * starts. + */ +flatbuffers.Builder.prototype.endVector = function() { + this.writeInt32(this.vector_num_elems); + return this.offset(); +}; +/// @endcond + +/** + * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed + * instead of a string, it is assumed to contain valid UTF-8 encoded data. + * + * @param {string|Uint8Array} s The string to encode + * @return {flatbuffers.Offset} The offset in the buffer where the encoded string starts + */ +flatbuffers.Builder.prototype.createString = function(s) { + if (s instanceof Uint8Array) { + var utf8 = s; + } else { + var utf8 = []; + var i = 0; + + while (i < s.length) { + var codePoint; + + // Decode UTF-16 + var a = s.charCodeAt(i++); + if (a < 0xD800 || a >= 0xDC00) { + codePoint = a; + } else { + var b = s.charCodeAt(i++); + codePoint = (a << 10) + b + (0x10000 - (0xD800 << 10) - 0xDC00); + } + + // Encode UTF-8 + if (codePoint < 0x80) { + utf8.push(codePoint); + } else { + if (codePoint < 0x800) { + utf8.push(((codePoint >> 6) & 0x1F) | 0xC0); + } else { + if (codePoint < 0x10000) { + utf8.push(((codePoint >> 12) & 0x0F) | 0xE0); + } else { + utf8.push( + ((codePoint >> 18) & 0x07) | 0xF0, + ((codePoint >> 12) & 0x3F) | 0x80); + } + utf8.push(((codePoint >> 6) & 0x3F) | 0x80); + } + utf8.push((codePoint & 0x3F) | 0x80); + } + } + } + + this.addInt8(0); + this.startVector(1, utf8.length, 1); + this.bb.setPosition(this.space -= utf8.length); + for (var i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) { + bytes[offset++] = utf8[i]; + } + return this.endVector(); +}; + +/** + * A helper function to avoid generated code depending on this file directly. + * + * @param {number} low + * @param {number} high + * @returns {flatbuffers.Long} + */ +flatbuffers.Builder.prototype.createLong = function(low, high) { + return flatbuffers.Long.create(low, high); +}; +//////////////////////////////////////////////////////////////////////////////// +/// @cond FLATBUFFERS_INTERNAL +/** + * Create a new ByteBuffer with a given array of bytes (`Uint8Array`). + * + * @constructor + * @param {Uint8Array} bytes + */ +flatbuffers.ByteBuffer = function(bytes) { + /** + * @type {Uint8Array} + * @private + */ + this.bytes_ = bytes; + + /** + * @type {number} + * @private + */ + this.position_ = 0; +}; + +/** + * Create and allocate a new ByteBuffer with a given size. + * + * @param {number} byte_size + * @returns {flatbuffers.ByteBuffer} + */ +flatbuffers.ByteBuffer.allocate = function(byte_size) { + return new flatbuffers.ByteBuffer(new Uint8Array(byte_size)); +}; + +flatbuffers.ByteBuffer.prototype.clear = function() { + this.position_ = 0; +}; + +/** + * Get the underlying `Uint8Array`. + * + * @returns {Uint8Array} + */ +flatbuffers.ByteBuffer.prototype.bytes = function() { + return this.bytes_; +}; + +/** + * Get the buffer's position. + * + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.position = function() { + return this.position_; +}; + +/** + * Set the buffer's position. + * + * @param {number} position + */ +flatbuffers.ByteBuffer.prototype.setPosition = function(position) { + this.position_ = position; +}; + +/** + * Get the buffer's capacity. + * + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.capacity = function() { + return this.bytes_.length; +}; + +/** + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.readInt8 = function(offset) { + return this.readUint8(offset) << 24 >> 24; +}; + +/** + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.readUint8 = function(offset) { + return this.bytes_[offset]; +}; + +/** + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.readInt16 = function(offset) { + return this.readUint16(offset) << 16 >> 16; +}; + +/** + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.readUint16 = function(offset) { + return this.bytes_[offset] | this.bytes_[offset + 1] << 8; +}; + +/** + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.readInt32 = function(offset) { + return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24; +}; + +/** + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.readUint32 = function(offset) { + return this.readInt32(offset) >>> 0; +}; + +/** + * @param {number} offset + * @returns {flatbuffers.Long} + */ +flatbuffers.ByteBuffer.prototype.readInt64 = function(offset) { + return new flatbuffers.Long(this.readInt32(offset), this.readInt32(offset + 4)); +}; + +/** + * @param {number} offset + * @returns {flatbuffers.Long} + */ +flatbuffers.ByteBuffer.prototype.readUint64 = function(offset) { + return new flatbuffers.Long(this.readUint32(offset), this.readUint32(offset + 4)); +}; + +/** + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.readFloat32 = function(offset) { + flatbuffers.int32[0] = this.readInt32(offset); + return flatbuffers.float32[0]; +}; + +/** + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.readFloat64 = function(offset) { + flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1] = this.readInt32(offset); + flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0] = this.readInt32(offset + 4); + return flatbuffers.float64[0]; +}; + +/** + * @param {number} offset + * @param {number|boolean} value + */ +flatbuffers.ByteBuffer.prototype.writeInt8 = function(offset, value) { + this.bytes_[offset] = /** @type {number} */(value); +}; + +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeUint8 = function(offset, value) { + this.bytes_[offset] = value; +}; + +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeInt16 = function(offset, value) { + this.bytes_[offset] = value; + this.bytes_[offset + 1] = value >> 8; +}; + +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeUint16 = function(offset, value) { + this.bytes_[offset] = value; + this.bytes_[offset + 1] = value >> 8; +}; + +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeInt32 = function(offset, value) { + this.bytes_[offset] = value; + this.bytes_[offset + 1] = value >> 8; + this.bytes_[offset + 2] = value >> 16; + this.bytes_[offset + 3] = value >> 24; +}; + +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeUint32 = function(offset, value) { + this.bytes_[offset] = value; + this.bytes_[offset + 1] = value >> 8; + this.bytes_[offset + 2] = value >> 16; + this.bytes_[offset + 3] = value >> 24; +}; + +/** + * @param {number} offset + * @param {flatbuffers.Long} value + */ +flatbuffers.ByteBuffer.prototype.writeInt64 = function(offset, value) { + this.writeInt32(offset, value.low); + this.writeInt32(offset + 4, value.high); +}; + +/** + * @param {number} offset + * @param {flatbuffers.Long} value + */ +flatbuffers.ByteBuffer.prototype.writeUint64 = function(offset, value) { + this.writeUint32(offset, value.low); + this.writeUint32(offset + 4, value.high); +}; + +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeFloat32 = function(offset, value) { + flatbuffers.float32[0] = value; + this.writeInt32(offset, flatbuffers.int32[0]); +}; + +/** + * @param {number} offset + * @param {number} value + */ +flatbuffers.ByteBuffer.prototype.writeFloat64 = function(offset, value) { + flatbuffers.float64[0] = value; + this.writeInt32(offset, flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1]); + this.writeInt32(offset + 4, flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0]); +}; + +/** + * Return the file identifier. Behavior is undefined for FlatBuffers whose + * schema does not include a file_identifier (likely points at padding or the + * start of a the root vtable). + * @returns {string} + */ +flatbuffers.ByteBuffer.prototype.getBufferIdentifier = function() { + if (this.bytes_.length < this.position_ + flatbuffers.SIZEOF_INT + + flatbuffers.FILE_IDENTIFIER_LENGTH) { + throw new Error( + 'FlatBuffers: ByteBuffer is too short to contain an identifier.'); + } + var result = ""; + for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) { + result += String.fromCharCode( + this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i)); + } + return result; +}; + +/** + * Look up a field in the vtable, return an offset into the object, or 0 if the + * field is not present. + * + * @param {number} bb_pos + * @param {number} vtable_offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.__offset = function(bb_pos, vtable_offset) { + var vtable = bb_pos - this.readInt32(bb_pos); + return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0; +}; + +/** + * Initialize any Table-derived type to point to the union at the given offset. + * + * @param {flatbuffers.Table} t + * @param {number} offset + * @returns {flatbuffers.Table} + */ +flatbuffers.ByteBuffer.prototype.__union = function(t, offset) { + t.bb_pos = offset + this.readInt32(offset); + t.bb = this; + return t; +}; + +/** + * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer. + * This allocates a new string and converts to wide chars upon each access. + * + * To avoid the conversion to UTF-16, pass flatbuffers.Encoding.UTF8_BYTES as + * the "optionalEncoding" argument. This is useful for avoiding conversion to + * and from UTF-16 when the data will just be packaged back up in another + * FlatBuffer later on. + * + * @param {number} offset + * @param {flatbuffers.Encoding=} opt_encoding Defaults to UTF16_STRING + * @returns {string|Uint8Array} + */ +flatbuffers.ByteBuffer.prototype.__string = function(offset, opt_encoding) { + offset += this.readInt32(offset); + + var length = this.readInt32(offset); + var result = ''; + var i = 0; + + offset += flatbuffers.SIZEOF_INT; + + if (opt_encoding === flatbuffers.Encoding.UTF8_BYTES) { + return this.bytes_.subarray(offset, offset + length); + } + + while (i < length) { + var codePoint; + + // Decode UTF-8 + var a = this.readUint8(offset + i++); + if (a < 0xC0) { + codePoint = a; + } else { + var b = this.readUint8(offset + i++); + if (a < 0xE0) { + codePoint = + ((a & 0x1F) << 6) | + (b & 0x3F); + } else { + var c = this.readUint8(offset + i++); + if (a < 0xF0) { + codePoint = + ((a & 0x0F) << 12) | + ((b & 0x3F) << 6) | + (c & 0x3F); + } else { + var d = this.readUint8(offset + i++); + codePoint = + ((a & 0x07) << 18) | + ((b & 0x3F) << 12) | + ((c & 0x3F) << 6) | + (d & 0x3F); + } + } + } + + // Encode UTF-16 + if (codePoint < 0x10000) { + result += String.fromCharCode(codePoint); + } else { + codePoint -= 0x10000; + result += String.fromCharCode( + (codePoint >> 10) + 0xD800, + (codePoint & ((1 << 10) - 1)) + 0xDC00); + } + } + + return result; +}; + +/** + * Retrieve the relative offset stored at "offset" + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.__indirect = function(offset) { + return offset + this.readInt32(offset); +}; + +/** + * Get the start of data of a vector whose offset is stored at "offset" in this object. + * + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.__vector = function(offset) { + return offset + this.readInt32(offset) + flatbuffers.SIZEOF_INT; // data starts after the length +}; + +/** + * Get the length of a vector whose offset is stored at "offset" in this object. + * + * @param {number} offset + * @returns {number} + */ +flatbuffers.ByteBuffer.prototype.__vector_len = function(offset) { + return this.readInt32(offset + this.readInt32(offset)); +}; + +/** + * @param {string} ident + * @returns {boolean} + */ +flatbuffers.ByteBuffer.prototype.__has_identifier = function(ident) { + if (ident.length != flatbuffers.FILE_IDENTIFIER_LENGTH) { + throw new Error('FlatBuffers: file identifier must be length ' + + flatbuffers.FILE_IDENTIFIER_LENGTH); + } + for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) { + if (ident.charCodeAt(i) != this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i)) { + return false; + } + } + return true; +}; + +/** + * A helper function to avoid generated code depending on this file directly. + * + * @param {number} low + * @param {number} high + * @returns {flatbuffers.Long} + */ +flatbuffers.ByteBuffer.prototype.createLong = function(low, high) { + return flatbuffers.Long.create(low, high); +}; + +// Exports for Node.js and RequireJS +this.flatbuffers = flatbuffers; + +/// @endcond +/// @} diff --git a/include/engine/api/flatbuffers/fbresult_generated.h b/include/engine/api/flatbuffers/fbresult_generated.h index ac81424de..47eb51806 100644 --- a/include/engine/api/flatbuffers/fbresult_generated.h +++ b/include/engine/api/flatbuffers/fbresult_generated.h @@ -804,12 +804,12 @@ struct IntersectionT : public flatbuffers::NativeTable { std::vector bearings; std::vector classes; std::vector entry; - uint32_t in; - uint32_t out; + uint32_t in_bearing; + uint32_t out_bearing; std::vector> lanes; IntersectionT() - : in(0), - out(0) { + : in_bearing(0), + out_bearing(0) { } }; @@ -820,8 +820,8 @@ struct Intersection FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_BEARINGS = 6, VT_CLASSES = 8, VT_ENTRY = 10, - VT_IN = 12, - VT_OUT = 14, + VT_IN_BEARING = 12, + VT_OUT_BEARING = 14, VT_LANES = 16 }; const osrm::engine::api::fbresult::Position *location() const { @@ -836,11 +836,11 @@ struct Intersection FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const flatbuffers::Vector *entry() const { return GetPointer *>(VT_ENTRY); } - uint32_t in() const { - return GetField(VT_IN, 0); + uint32_t in_bearing() const { + return GetField(VT_IN_BEARING, 0); } - uint32_t out() const { - return GetField(VT_OUT, 0); + uint32_t out_bearing() const { + return GetField(VT_OUT_BEARING, 0); } const flatbuffers::Vector> *lanes() const { return GetPointer> *>(VT_LANES); @@ -855,8 +855,8 @@ struct Intersection FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyVectorOfStrings(classes()) && VerifyOffset(verifier, VT_ENTRY) && verifier.VerifyVector(entry()) && - VerifyField(verifier, VT_IN) && - VerifyField(verifier, VT_OUT) && + VerifyField(verifier, VT_IN_BEARING) && + VerifyField(verifier, VT_OUT_BEARING) && VerifyOffset(verifier, VT_LANES) && verifier.VerifyVector(lanes()) && verifier.VerifyVectorOfTables(lanes()) && @@ -882,11 +882,11 @@ struct IntersectionBuilder { void add_entry(flatbuffers::Offset> entry) { fbb_.AddOffset(Intersection::VT_ENTRY, entry); } - void add_in(uint32_t in) { - fbb_.AddElement(Intersection::VT_IN, in, 0); + void add_in_bearing(uint32_t in_bearing) { + fbb_.AddElement(Intersection::VT_IN_BEARING, in_bearing, 0); } - void add_out(uint32_t out) { - fbb_.AddElement(Intersection::VT_OUT, out, 0); + void add_out_bearing(uint32_t out_bearing) { + fbb_.AddElement(Intersection::VT_OUT_BEARING, out_bearing, 0); } void add_lanes(flatbuffers::Offset>> lanes) { fbb_.AddOffset(Intersection::VT_LANES, lanes); @@ -909,13 +909,13 @@ inline flatbuffers::Offset CreateIntersection( flatbuffers::Offset> bearings = 0, flatbuffers::Offset>> classes = 0, flatbuffers::Offset> entry = 0, - uint32_t in = 0, - uint32_t out = 0, + uint32_t in_bearing = 0, + uint32_t out_bearing = 0, flatbuffers::Offset>> lanes = 0) { IntersectionBuilder builder_(_fbb); builder_.add_lanes(lanes); - builder_.add_out(out); - builder_.add_in(in); + builder_.add_out_bearing(out_bearing); + builder_.add_in_bearing(in_bearing); builder_.add_entry(entry); builder_.add_classes(classes); builder_.add_bearings(bearings); @@ -929,8 +929,8 @@ inline flatbuffers::Offset CreateIntersectionDirect( const std::vector *bearings = nullptr, const std::vector> *classes = nullptr, const std::vector *entry = nullptr, - uint32_t in = 0, - uint32_t out = 0, + uint32_t in_bearing = 0, + uint32_t out_bearing = 0, const std::vector> *lanes = nullptr) { auto bearings__ = bearings ? _fbb.CreateVector(*bearings) : 0; auto classes__ = classes ? _fbb.CreateVector>(*classes) : 0; @@ -942,8 +942,8 @@ inline flatbuffers::Offset CreateIntersectionDirect( bearings__, classes__, entry__, - in, - out, + in_bearing, + out_bearing, lanes__); } @@ -2088,8 +2088,8 @@ inline void Intersection::UnPackTo(IntersectionT *_o, const flatbuffers::resolve { auto _e = bearings(); if (_e) { _o->bearings.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->bearings[_i] = _e->Get(_i); } } }; { auto _e = classes(); if (_e) { _o->classes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->classes[_i] = _e->Get(_i)->str(); } } }; { auto _e = entry(); if (_e) { _o->entry.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->entry[_i] = _e->Get(_i) != 0; } } }; - { auto _e = in(); _o->in = _e; }; - { auto _e = out(); _o->out = _e; }; + { auto _e = in_bearing(); _o->in_bearing = _e; }; + { auto _e = out_bearing(); _o->out_bearing = _e; }; { auto _e = lanes(); if (_e) { _o->lanes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lanes[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } }; } @@ -2105,8 +2105,8 @@ inline flatbuffers::Offset CreateIntersection(flatbuffers::FlatBuf auto _bearings = _o->bearings.size() ? _fbb.CreateVector(_o->bearings) : 0; auto _classes = _o->classes.size() ? _fbb.CreateVectorOfStrings(_o->classes) : 0; auto _entry = _o->entry.size() ? _fbb.CreateVector(_o->entry) : 0; - auto _in = _o->in; - auto _out = _o->out; + auto _in_bearing = _o->in_bearing; + auto _out_bearing = _o->out_bearing; auto _lanes = _o->lanes.size() ? _fbb.CreateVector> (_o->lanes.size(), [](size_t i, _VectorArgs *__va) { return CreateLane(*__va->__fbb, __va->__o->lanes[i].get(), __va->__rehasher); }, &_va ) : 0; return osrm::engine::api::fbresult::CreateIntersection( _fbb, @@ -2114,8 +2114,8 @@ inline flatbuffers::Offset CreateIntersection(flatbuffers::FlatBuf _bearings, _classes, _entry, - _in, - _out, + _in_bearing, + _out_bearing, _lanes); } diff --git a/include/engine/api/flatbuffers/route.fbs b/include/engine/api/flatbuffers/route.fbs index 679fc2992..902bfa199 100644 --- a/include/engine/api/flatbuffers/route.fbs +++ b/include/engine/api/flatbuffers/route.fbs @@ -65,8 +65,8 @@ table Intersection { bearings: [short]; classes: [string]; entry: [bool]; - in: uint; - out: uint; + in_bearing: uint; + out_bearing: uint; lanes: [Lane]; } diff --git a/include/engine/api/route_api.hpp b/include/engine/api/route_api.hpp index d3c19b04f..6450e6b56 100644 --- a/include/engine/api/route_api.hpp +++ b/include/engine/api/route_api.hpp @@ -688,8 +688,8 @@ class RouteAPI : public BaseAPI intersectionBuilder.add_bearings(bearings_vector); intersectionBuilder.add_classes(classes_vector); intersectionBuilder.add_entry(entry_vector); - intersectionBuilder.add_in(intersection.in); - intersectionBuilder.add_out(intersection.out); + intersectionBuilder.add_in_bearing(intersection.in); + intersectionBuilder.add_out_bearing(intersection.out); intersectionBuilder.add_lanes(lanes_vector); return intersectionBuilder.Finish(); }); diff --git a/unit_tests/library/route.cpp b/unit_tests/library/route.cpp index 4ff7446b3..2372fb9cb 100644 --- a/unit_tests/library/route.cpp +++ b/unit_tests/library/route.cpp @@ -562,11 +562,11 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb) if (step_count > 0) { - BOOST_CHECK(intersection->in() < bearings->size()); + BOOST_CHECK(intersection->in_bearing() < bearings->size()); } if (step_count + 1 < steps->size()) { - BOOST_CHECK(intersection->out() < bearings->size()); + BOOST_CHECK(intersection->out_bearing() < bearings->size()); } } ++step_count;