molstar
Version:
A comprehensive macromolecular library.
211 lines • 8.82 kB
JavaScript
;
/**
* Copyright (c) 2017-2019 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.toTable = exports.toDatabase = exports.toDatabaseCollection = exports.FieldPath = void 0;
var tslib_1 = require("tslib");
var db_1 = require("../../../mol-data/db");
var linear_algebra_1 = require("../../../mol-math/linear-algebra");
var mol_util_1 = require("../../../mol-util");
var Data = (0, tslib_1.__importStar)(require("./data-model"));
var FieldPath;
(function (FieldPath) {
function canonical(path) {
return path.replace('.', '_').replace(/\[/, '_').replace(/(\[|\])/g, '');
}
FieldPath.canonical = canonical;
function equal(pathA, pathB) {
return canonical(pathA) === canonical(pathB);
}
FieldPath.equal = equal;
function create(category, field, asCanonical) {
if (asCanonical === void 0) { asCanonical = false; }
var p = "" + category + (field ? "." + field : '');
return asCanonical ? canonical(p) : p;
}
FieldPath.create = create;
})(FieldPath = exports.FieldPath || (exports.FieldPath = {}));
function toDatabaseCollection(schema, file, aliases) {
var dbc = {};
for (var _i = 0, _a = file.blocks; _i < _a.length; _i++) {
var data = _a[_i];
dbc[data.header] = toDatabase(schema, data, aliases);
}
return dbc;
}
exports.toDatabaseCollection = toDatabaseCollection;
function toDatabase(schema, frame, aliases) {
return createDatabase(schema, frame, aliases);
}
exports.toDatabase = toDatabase;
function toTable(schema, category) {
return new CategoryTable(category, schema, true);
}
exports.toTable = toTable;
function getColumnCtor(t) {
switch (t.valueType) {
case 'str': return function (f, c, k) { return createColumn(t, f, f.str, f.toStringArray); };
case 'int': return function (f, c, k) { return createColumn(t, f, f.int, f.toIntArray); };
case 'float': return function (f, c, k) { return createColumn(t, f, f.float, f.toFloatArray); };
case 'list': throw new Error('Use createListColumn instead.');
case 'tensor': throw new Error('Use createTensorColumn instead.');
}
}
function createColumn(schema, field, value, toArray) {
return {
schema: schema,
__array: field.__array,
isDefined: field.isDefined,
rowCount: field.rowCount,
value: value,
valueKind: field.valueKind,
areValuesEqual: field.areValuesEqual,
toArray: toArray
};
}
function createListColumn(schema, category, key) {
var separator = schema.separator;
var itemParse = schema.itemParse;
var f = category.getField(key);
var value = f ? function (row) { return f.str(row).split(separator).map(function (x) { return itemParse(x.trim()); }).filter(function (x) { return !!x; }); } : function (row) { return []; };
var toArray = function (params) { return db_1.ColumnHelpers.createAndFillArray(category.rowCount, value, params); };
return {
schema: schema,
__array: void 0,
isDefined: !!f,
rowCount: category.rowCount,
value: value,
valueKind: f ? f.valueKind : function () { return 1 /* NotPresent */; },
areValuesEqual: function (rowA, rowB) { return (0, mol_util_1.arrayEqual)(value(rowA), value(rowB)); },
toArray: toArray
};
}
function createTensorColumn(schema, category, key) {
var space = schema.space;
var zeroOffset = (category.fieldNames.includes(key + "[0]") ||
category.fieldNames.includes(key + "[0][0]") ||
category.fieldNames.includes(key + "[0][0][0]"));
var fst = zeroOffset ? 0 : 1;
var namingVariant = (category.fieldNames.includes(key + "_1") ||
category.fieldNames.includes(key + "_11") ||
category.fieldNames.includes(key + "_111")) ? 'underscore' : 'brackets';
var getName = Data.tensorFieldNameGetter(key, space.rank, zeroOffset, namingVariant);
var first = category.getField(getName(fst, fst, fst)) || db_1.Column.Undefined(category.rowCount, schema);
var value = function (row) { return Data.getTensor(category, space, row, getName); };
var toArray = function (params) { return db_1.ColumnHelpers.createAndFillArray(category.rowCount, value, params); };
return {
schema: schema,
__array: void 0,
isDefined: first.isDefined,
rowCount: category.rowCount,
value: value,
valueKind: first.valueKind,
areValuesEqual: function (rowA, rowB) { return linear_algebra_1.Tensor.areEqualExact(value(rowA), value(rowB)); },
toArray: toArray
};
}
var CategoryTable = /** @class */ (function () {
function CategoryTable(category, schema, _isDefined) {
this._isDefined = _isDefined;
var fieldKeys = Object.keys(schema);
this._rowCount = category.rowCount;
this._columns = fieldKeys;
this._schema = schema;
var cache = Object.create(null);
var _loop_1 = function (k) {
Object.defineProperty(this_1, k, {
get: function () {
if (cache[k])
return cache[k];
var fType = schema[k];
if (fType.valueType === 'list') {
cache[k] = createListColumn(fType, category, k);
}
else if (fType.valueType === 'tensor') {
cache[k] = createTensorColumn(fType, category, k);
}
else {
var ctor = getColumnCtor(fType);
var field = category.getField(k);
cache[k] = !!field ? ctor(field, category, k) : db_1.Column.Undefined(category.rowCount, fType);
}
return cache[k];
},
enumerable: true,
configurable: false
});
};
var this_1 = this;
for (var _i = 0, fieldKeys_1 = fieldKeys; _i < fieldKeys_1.length; _i++) {
var k = fieldKeys_1[_i];
_loop_1(k);
}
}
return CategoryTable;
}());
function createDatabase(schema, frame, aliases) {
var tables = Object.create(null);
for (var _i = 0, _a = Object.keys(schema); _i < _a.length; _i++) {
var k = _a[_i];
tables[k] = createTable(k, schema[k], frame, aliases);
}
return db_1.Database.ofTables(frame.header, schema, tables);
}
function flattenFrame(frame) {
var flatFrame = Object.create(null);
for (var _i = 0, _a = Object.keys(frame.categories); _i < _a.length; _i++) {
var c = _a[_i];
for (var _b = 0, _c = frame.categories[c].fieldNames; _b < _c.length; _b++) {
var f = _c[_b];
var p = FieldPath.create(c, f, true);
flatFrame[p] = frame.categories[c].getField(f);
}
}
return flatFrame;
}
function getField(field, category, flatFrame, aliases) {
var path = FieldPath.create(category, field);
var canonicalPath = FieldPath.canonical(path);
if (canonicalPath in flatFrame)
return flatFrame[canonicalPath];
if (aliases && path in aliases) {
for (var _i = 0, _a = aliases[path]; _i < _a.length; _i++) {
var aliased = _a[_i];
var canonicalAliased = FieldPath.canonical(aliased);
if (canonicalAliased in flatFrame)
return flatFrame[canonicalAliased];
}
}
}
function createTable(key, schema, frame, aliases) {
var cat = frame.categories[key];
if (aliases) {
var flatFrame = flattenFrame(frame);
var fields_1 = Object.create(null);
var fieldNames = [];
var rowCount = 0;
for (var _i = 0, _a = Object.keys(schema); _i < _a.length; _i++) {
var k = _a[_i];
var field = getField(k, key, flatFrame, aliases);
if (field) {
fields_1[k] = field;
fieldNames.push(k);
rowCount = field.rowCount;
}
}
cat = {
rowCount: rowCount,
name: key,
fieldNames: (0, tslib_1.__spreadArray)([], fieldNames, true),
getField: function (name) {
return fields_1[name];
}
};
}
return new CategoryTable(cat || Data.CifCategory.empty(key), schema, !!cat);
}
//# sourceMappingURL=schema.js.map