molstar
Version:
A comprehensive macromolecular library.
270 lines • 11.2 kB
JavaScript
;
/**
* Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author David Sehnal <david.sehnal@gmail.com>
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.Encoder = exports.Category = exports.Field = void 0;
var tslib_1 = require("tslib");
var iterator_1 = require("../../../mol-data/iterator");
var binary_cif_1 = require("../../common/binary-cif");
var Field;
(function (Field) {
function str(name, value, params) {
return { name: name, type: 0 /* Str */, value: value, valueKind: params && params.valueKind, defaultFormat: params && params.encoder ? { encoder: params.encoder } : void 0, shouldInclude: params && params.shouldInclude };
}
Field.str = str;
function int(name, value, params) {
return {
name: name,
type: 1 /* Int */,
value: value,
valueKind: params && params.valueKind,
defaultFormat: params ? { encoder: params.encoder, typedArray: params.typedArray } : void 0,
shouldInclude: params && params.shouldInclude
};
}
Field.int = int;
function float(name, value, params) {
return {
name: name,
type: 2 /* Float */,
value: value,
valueKind: params && params.valueKind,
defaultFormat: params ? { encoder: params.encoder, typedArray: params.typedArray, digitCount: typeof params.digitCount !== 'undefined' ? params.digitCount : void 0 } : void 0,
shouldInclude: params && params.shouldInclude
};
}
Field.float = float;
function index(name) {
return int(name, function (e, d, i) { return i + 1; }, { typedArray: Int32Array, encoder: binary_cif_1.ArrayEncoding.by(binary_cif_1.ArrayEncoding.delta).and(binary_cif_1.ArrayEncoding.runLength).and(binary_cif_1.ArrayEncoding.integerPacking) });
}
Field.index = index;
var Builder = /** @class */ (function () {
function Builder() {
this.fields = [];
}
Builder.prototype.index = function (name) {
this.fields.push(Field.index(name));
return this;
};
Builder.prototype.str = function (name, value, params) {
this.fields.push(Field.str(name, value, params));
return this;
};
Builder.prototype.int = function (name, value, params) {
this.fields.push(Field.int(name, value, params));
return this;
};
Builder.prototype.vec = function (name, values, params) {
for (var i = 0; i < values.length; i++) {
this.fields.push(Field.int(name + "[" + (i + 1) + "]", values[i], params));
}
return this;
};
Builder.prototype.float = function (name, value, params) {
this.fields.push(Field.float(name, value, params));
return this;
};
Builder.prototype.many = function (fields) {
for (var i = 0; i < fields.length; i++)
this.fields.push(fields[i]);
return this;
};
Builder.prototype.add = function (field) {
this.fields.push(field);
return this;
};
Builder.prototype.getFields = function () { return this.fields; };
return Builder;
}());
Field.Builder = Builder;
function build() {
return new Builder();
}
Field.build = build;
})(Field = exports.Field || (exports.Field = {}));
var Category;
(function (Category) {
Category.Empty = { fields: [], source: [] };
function filterOf(directives) {
var cat_whitelist = [];
var cat_blacklist = [];
var field_whitelist = [];
var field_blacklist = [];
for (var _i = 0, _a = directives.split(/[\r\n]+/); _i < _a.length; _i++) {
var d = _a[_i];
d = d.trim();
// allow for empty lines in config
if (d.length === 0)
continue;
// let ! denote blacklisted entries
var blacklist = /^!/.test(d);
if (blacklist)
d = d.substr(1);
var split = d.split(/\./);
var field = split[1];
var list = blacklist ? (field ? field_blacklist : cat_blacklist) : (field ? field_whitelist : cat_whitelist);
list[list.length] = d;
// ensure categories are aware about whitelisted columns
if (field && !cat_whitelist.includes(split[0])) {
cat_whitelist[cat_whitelist.length] = split[0];
}
}
var wlcatcol = field_whitelist.map(function (it) { return it.split('.')[0]; });
// blacklist has higher priority
return {
includeCategory: function (cat) {
// block if category in black
if (cat_blacklist.includes(cat)) {
return false;
}
else {
// if there is a whitelist, the category has to be explicitly allowed
return cat_whitelist.length <= 0 ||
// otherwise include if whitelist contains category
cat_whitelist.indexOf(cat) !== -1;
}
},
includeField: function (cat, field) {
// column names are assumed to follow the pattern 'category_name.column_name'
var full = cat + '.' + field;
if (field_blacklist.includes(full)) {
return false;
}
else {
// if for this category no whitelist entries exist
return !wlcatcol.includes(cat) ||
// otherwise must be specifically allowed
field_whitelist.includes(full);
}
}
};
}
Category.filterOf = filterOf;
Category.DefaultFilter = {
includeCategory: function (cat) { return true; },
includeField: function (cat, field) { return true; }
};
Category.DefaultFormatter = {
getFormat: function (cat, field) { return void 0; }
};
function ofTable(table, indices) {
if (indices) {
return {
fields: cifFieldsFromTableSchema(table._schema),
source: [{ data: table, rowCount: indices.length, keys: function () { return iterator_1.Iterator.Array(indices); } }]
};
}
return {
fields: cifFieldsFromTableSchema(table._schema),
source: [{ data: table, rowCount: table._rowCount }]
};
}
Category.ofTable = ofTable;
})(Category = exports.Category || (exports.Category = {}));
var Encoder;
(function (Encoder) {
function writeDatabase(encoder, name, database) {
encoder.startDataBlock(name);
var _loop_1 = function (table) {
encoder.writeCategory({ name: table, instance: function () { return Category.ofTable(database[table]); } });
};
for (var _i = 0, _a = database._tableNames; _i < _a.length; _i++) {
var table = _a[_i];
_loop_1(table);
}
}
Encoder.writeDatabase = writeDatabase;
function writeDatabaseCollection(encoder, collection) {
for (var _i = 0, _a = Object.keys(collection); _i < _a.length; _i++) {
var name_1 = _a[_i];
writeDatabase(encoder, name_1, collection[name_1]);
}
}
Encoder.writeDatabaseCollection = writeDatabaseCollection;
})(Encoder = exports.Encoder || (exports.Encoder = {}));
function columnValue(k) {
return function (i, d) { return d[k].value(i); };
}
function columnListValue(k) {
return function (i, d) { return d[k].value(i).join(d[k].schema.separator); };
}
function columnTensorValue(k) {
var coords = [];
for (var _i = 1; _i < arguments.length; _i++) {
coords[_i - 1] = arguments[_i];
}
return function (i, d) {
var _a;
return (_a = d[k].schema.space).get.apply(_a, (0, tslib_1.__spreadArray)([d[k].value(i)], coords, false));
};
}
function columnValueKind(k) {
return function (i, d) { return d[k].valueKind(i); };
}
function getTensorDefinitions(field, space) {
var fieldDefinitions = [];
var type = 2 /* Float */;
var valueKind = columnValueKind(field);
if (space.rank === 1) {
var rows = space.dimensions[0];
for (var i = 0; i < rows; i++) {
var name_2 = field + "[" + (i + 1) + "]";
fieldDefinitions.push({ name: name_2, type: type, value: columnTensorValue(field, i), valueKind: valueKind });
}
}
else if (space.rank === 2) {
var rows = space.dimensions[0], cols = space.dimensions[1];
for (var i = 0; i < rows; i++) {
for (var j = 0; j < cols; j++) {
var name_3 = field + "[" + (i + 1) + "][" + (j + 1) + "]";
fieldDefinitions.push({ name: name_3, type: type, value: columnTensorValue(field, i, j), valueKind: valueKind });
}
}
}
else if (space.rank === 3) {
var d0 = space.dimensions[0], d1 = space.dimensions[1], d2 = space.dimensions[2];
for (var i = 0; i < d0; i++) {
for (var j = 0; j < d1; j++) {
for (var k = 0; k < d2; k++) {
var name_4 = field + "[" + (i + 1) + "][" + (j + 1) + "][" + (k + 1) + "]";
fieldDefinitions.push({ name: name_4, type: type, value: columnTensorValue(field, i, j, k), valueKind: valueKind });
}
}
}
}
else {
throw new Error('Tensors with rank > 3 or rank 0 are currently not supported.');
}
return fieldDefinitions;
}
function cifFieldsFromTableSchema(schema) {
var fields = [];
for (var _i = 0, _a = Object.keys(schema); _i < _a.length; _i++) {
var k = _a[_i];
var t = schema[k];
if (t.valueType === 'int') {
fields.push({ name: k, type: 1 /* Int */, value: columnValue(k), valueKind: columnValueKind(k) });
}
else if (t.valueType === 'float') {
fields.push({ name: k, type: 2 /* Float */, value: columnValue(k), valueKind: columnValueKind(k) });
}
else if (t.valueType === 'str') {
fields.push({ name: k, type: 0 /* Str */, value: columnValue(k), valueKind: columnValueKind(k) });
}
else if (t.valueType === 'list') {
fields.push({ name: k, type: 0 /* Str */, value: columnListValue(k), valueKind: columnValueKind(k) });
}
else if (t.valueType === 'tensor') {
fields.push.apply(fields, getTensorDefinitions(k, t.space));
}
else {
throw new Error("Unknown valueType " + t.valueType);
}
}
return fields;
}
//# sourceMappingURL=encoder.js.map