started cif writer

src/mol-base/utils/string-builder.ts

@@ -6,7 +6,6 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-
 interface StringBuilder {
     current: string[],
     offset: number,
@@ -63,7 +62,11 @@ namespace StringBuilder {
     }
 
     export function whitespace(builder: StringBuilder, len: number) {
-        if (len > 0) write(builder, __paddingSpaces[len]);
+        if (len > 0) writeSafe(builder, __paddingSpaces[len]);
+    }
+
+    export function whitespace1(builder: StringBuilder) {
+        writeSafe(builder, ' ');
     }
 
     export function write(builder: StringBuilder, val: string) {
@@ -108,6 +111,10 @@ namespace StringBuilder {
         writeSafe(builder, '' + val);
     }
 
+    export function writeIntegerAndSpace(builder: StringBuilder, val: number) {
+        writeSafe(builder, '' + val + ' ');
+    }
+
     export function writeIntegerPadLeft(builder: StringBuilder, val: number, totalWidth: number) {
         let s = '' + val;
         let padding = totalWidth - s.length;

src/mol-io/writer/cif/TODO

@@ -1,3 +0,0 @@
-- Make a writer that takes a database and produces a CIF/BinaryCIF file.
-- Make a more generic writer that takes Iterator<Key> and column spec with value: (ctx: Ctx, key: Key) => number | string | undefined /* NotPresent */ | null /* unknown */
-  - This will work with Structure.atomLocations for atom_site

src/mol-io/writer/cif/encoder.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import Iterator from 'mol-base/collections/iterator'
+import { Column } from 'mol-base/collections/database'
+import Encoder from '../encoder'
+
+export const enum FieldType {
+    Str, Int, Float
+}
+
+export interface FieldDefinition<Key = any, Data = any> {
+    name: string,
+    type: FieldType,
+    value(key: Key, data: Data): string | number,
+    valueKind?: (key: Key, data: Data) => Column.ValueKind
+
+    /** determine whether to include this field base on the context */
+    shouldInclude?: (data: Data) => boolean
+}
+
+export interface FieldFormat {
+    decimalPlaces: number
+}
+
+export namespace FieldFormat {
+    export const Default: FieldFormat = { decimalPlaces: 3 };
+}
+
+export interface CategoryDefinition<Key = any, Data = any> {
+    name: string,
+    fields: FieldDefinition<Key, Data>[]
+}
+
+export interface CategoryInstance<Key = any, Data = any> {
+    data: Data,
+    definition: CategoryDefinition<Key, Data>,
+    formats?: { [name: string]: Partial<FieldFormat> },
+    rowCount: number,
+    keys(): Iterator<Key>
+}
+
+export interface CategoryProvider {
+    (ctx: any): CategoryInstance
+}
+
+export interface CIFEncoder<T, Context> extends Encoder<T> {
+    startDataBlock(header: string): void,
+    writeCategory(category: CategoryProvider, contexts?: Context[]): void,
+    getData(): T
+}

src/mol-io/writer/cif/encoder/text.ts

@@ -0,0 +1,228 @@
+/**
+ * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Adapted from CIFTools.js (https://github.com/dsehnal/CIFTools.js)
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { Column } from 'mol-base/collections/database'
+import StringBuilder from 'mol-base/utils/string-builder'
+import * as Enc from '../encoder'
+import Writer from '../../writer'
+
+export default class TextCIFEncoder<Context> implements Enc.CIFEncoder<string, Context> {
+    private builder = StringBuilder.create();
+    private encoded = false;
+    private dataBlockCreated = false;
+
+    startDataBlock(header: string) {
+        this.dataBlockCreated = true;
+        StringBuilder.write(this.builder, `data_${(header || '').replace(/[ \n\t]/g, '').toUpperCase()}\n#\n`);
+    }
+
+    writeCategory(category: Enc.CategoryProvider, contexts?: Context[]) {
+        if (this.encoded) {
+            throw new Error('The writer contents have already been encoded, no more writing.');
+        }
+
+        if (!this.dataBlockCreated) {
+            throw new Error('No data block created.');
+        }
+
+        const categories = !contexts || !contexts.length ? [category(<any>void 0)] : contexts.map(c => category(c));
+        if (!categories.length) return;
+
+        const rowCount = categories.reduce((v, c) => v + c.rowCount, 0);
+
+        if (rowCount === 0) return;
+
+        if (rowCount === 1) {
+            writeCifSingleRecord(categories[0]!, this.builder);
+        } else {
+            writeCifLoop(categories, this.builder);
+        }
+    }
+
+    encode() {
+        this.encoded = true;
+    }
+
+    writeTo(stream: Writer<string>) {
+        const chunks = StringBuilder.getChunks(this.builder);
+        for (let i = 0, _i = chunks.length; i < _i; i++) {
+            stream.write(chunks[i]);
+        }
+    }
+
+    getData() {
+        return StringBuilder.getString(this.builder);
+    }
+}
+
+function writeValue(builder: StringBuilder, data: any, key: any, f: Enc.FieldDefinition): boolean {
+    const kind = f.valueKind;
+    const p = kind ? kind(key, data) : Column.ValueKind.Present;
+    if (p !== Column.ValueKind.Present) {
+        if (p === Column.ValueKind.NotPresent) writeNotPresent(builder);
+        else writeUnknown(builder);
+    } else {
+        const val = f.value(key, data);
+        const t = f.type;
+        if (t === Enc.FieldType.Str) {
+            if (isMultiline(val as string)) {
+                writeMultiline(builder, val as string);
+                return true;
+            } else {
+                return writeChecked(builder, val as string);
+            }
+        } else if (t === Enc.FieldType.Int) {
+            writeInteger(builder, val as number);
+        } else {
+            writeFloat(builder, val as number, 1000);
+        }
+    }
+    return false;
+}
+
+function writeCifSingleRecord(category: Enc.CategoryInstance<any>, builder: StringBuilder) {
+    const fields = category.definition.fields;
+    const data = category.data;
+    const width = fields.reduce((w, s) => Math.max(w, s.name.length), 0) + category.definition.name.length + 6;
+
+    const it = category.keys();
+    const key = it.move();
+
+    for (let _f = 0; _f < fields.length; _f++) {
+        const f = fields[_f];
+        StringBuilder.writePadRight(builder, `_${category.definition.name}.${f.name}`, width);
+        const multiline = writeValue(builder, data, key, f);
+        if (!multiline) StringBuilder.newline(builder);
+    }
+    StringBuilder.write(builder, '#\n');
+}
+
+function writeCifLoop(categories: Enc.CategoryInstance[], builder: StringBuilder) {
+    const first = categories[0];
+    const fields = first.definition.fields;
+    const fieldCount = fields.length;
+
+    writeLine(builder, 'loop_');
+    for (let i = 0; i < fieldCount; i++) {
+        writeLine(builder, `_${first.definition.name}.${fields[i].name}`);
+    }
+
+    for (let _c = 0; _c < categories.length; _c++) {
+        const category = categories[_c];
+        const data = category.data;
+
+        if (category.rowCount === 0) continue;
+
+        const it = category.keys();
+        while (it.hasNext)  {
+            const key = it.move();
+
+            let multiline = false;
+            for (let _f = 0; _f < fieldCount; _f++) {
+                multiline = writeValue(builder, data, key, fields[_f]);
+            }
+            if (!multiline) StringBuilder.newline(builder);
+        }
+    }
+    StringBuilder.write(builder, '#\n');
+}
+
+function isMultiline(value: string) {
+    return !!value && value.indexOf('\n') >= 0;
+}
+
+function writeLine(builder: StringBuilder, val: string) {
+    StringBuilder.write(builder, val);
+    StringBuilder.newline(builder);
+}
+
+function writeInteger(builder: StringBuilder, val: number) {
+    StringBuilder.writeInteger(builder, val);
+    StringBuilder.whitespace1(builder);
+}
+
+function writeFloat(builder: StringBuilder, val: number, precisionMultiplier: number) {
+    StringBuilder.writeFloat(builder, val, precisionMultiplier);
+    StringBuilder.whitespace1(builder);
+}
+
+function writeNotPresent(builder: StringBuilder) {
+    StringBuilder.writeSafe(builder, '. ');
+}
+
+function writeUnknown(builder: StringBuilder) {
+    StringBuilder.writeSafe(builder, '? ');
+}
+
+function writeChecked(builder: StringBuilder, val: string) {
+    if (!val) {
+        StringBuilder.writeSafe(builder, '. ');
+        return false;
+    }
+
+    let escape = false, escapeCharStart = '\'', escapeCharEnd = '\' ';
+    let hasWhitespace = false;
+    let hasSingle = false;
+    let hasDouble = false;
+    for (let i = 0, _l = val.length - 1; i < _l; i++) {
+        const c = val.charCodeAt(i);
+
+        switch (c) {
+            case 9: hasWhitespace = true; break; // \t
+            case 10: // \n
+                writeMultiline(builder, val);
+                return true;
+            case 32: hasWhitespace = true; break; // ' '
+            case 34: // "
+                if (hasSingle) {
+                    writeMultiline(builder, val);
+                    return true;
+                }
+
+                hasDouble = true;
+                escape = true;
+                escapeCharStart = '\'';
+                escapeCharEnd = '\' ';
+                break;
+            case 39: // '
+                if (hasDouble) {
+                    writeMultiline(builder, val);
+                    return true;
+                }
+
+                escape = true;
+                hasSingle = true;
+                escapeCharStart = '"';
+                escapeCharEnd = '" ';
+                break;
+        }
+    }
+
+    const fst = val.charCodeAt(0);
+    if (!escape && (fst === 35 /* # */ || fst === 59 /* ; */ || hasWhitespace)) {
+        escapeCharStart = '\'';
+        escapeCharEnd = '\' ';
+        escape = true;
+    }
+
+    if (escape) {
+        StringBuilder.writeSafe(builder, escapeCharStart);
+        StringBuilder.writeSafe(builder, val);
+        StringBuilder.writeSafe(builder, escapeCharEnd);
+    } else {
+        StringBuilder.writeSafe(builder, val);
+        StringBuilder.writeSafe(builder, ' ');
+    }
+
+    return false;
+}
+
+function writeMultiline(builder: StringBuilder, val: string) {
+    StringBuilder.writeSafe(builder, '\n;' + val);
+    StringBuilder.writeSafe(builder, '\n;\n');
+}

src/mol-io/writer/encoder.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import Writer from './writer'
+
+interface Encoder<T> {
+    encode(): void,
+    writeTo(writer: Writer<T>): void
+}
+
+export default Encoder

src/mol-io/writer/writer.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+interface Writer<T> {
+    write(data: T): boolean
+}
+
+namespace Writer {
+
+}
+
+export default Writer

src/perf-tests/cif-encoder.ts

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import Iterator from 'mol-base/collections/iterator'
+import * as Enc from 'mol-io/writer/cif/encoder'
+import CW from 'mol-io/writer/cif/encoder/text'
+
+const category1: Enc.CategoryDefinition<number> = {
+    name: 'test',
+    fields: [{
+        name: 'f1',
+        type: Enc.FieldType.Str,
+        value: i => 'v' + i
+    }, {
+        name: 'f2',
+        type: Enc.FieldType.Int,
+        value: i => i * i
+    }, {
+        name: 'f3',
+        type: Enc.FieldType.Float,
+        value: i => Math.random()
+    }]
+}
+
+const category2: Enc.CategoryDefinition<number> = {
+    name: 'test2',
+    fields: [{
+        name: 'e1',
+        type: Enc.FieldType.Str,
+        value: i => 'v\n' + i
+    }, {
+        name: 'e2',
+        type: Enc.FieldType.Int,
+        value: i => i * i
+    }, {
+        name: 'e3',
+        type: Enc.FieldType.Float,
+        value: i => Math.random()
+    }]
+}
+
+function getInstace(ctx: { cat: Enc.CategoryDefinition<number>, rowCount: number }): Enc.CategoryInstance {
+    return {
+        data: void 0,
+        definition: ctx.cat,
+        keys: () => Iterator.Range(0, ctx.rowCount - 1),
+        rowCount: ctx.rowCount
+    }
+}
+
+const w = new CW();
+
+w.startDataBlock('test');
+w.writeCategory(getInstace, [{ rowCount: 5, cat: category1 }]);
+w.writeCategory(getInstace, [{ rowCount: 1, cat: category2 }]);
+console.log(w.getData());

src/perf-tests/string-builder.ts

@@ -14,32 +14,42 @@ export namespace Test {
         const sb = SB.create(chunkSize);
         for (let i = 0, _i = data.length; i < _i; i++) {
             SB.writeSafe(sb, data[i]);
+            SB.whitespace1(sb);
         }
         return sb;
     }
 
-    function naive(data: string[]) {
-        let ret = '';
-        for (let i = 0, _i = data.length; i < _i; i++) ret += data[i];
-        return ret;
+    function buildWS(data: string[], chunkSize: number): SB {
+        const sb = SB.create(chunkSize);
+        for (let i = 0, _i = data.length; i < _i; i++) {
+            SB.writeSafe(sb, data[i] + ' ');
+        }
+        return sb;
     }
 
-    function join(data: string[]) {
-        let ret = [];
-        for (let i = 0, _i = data.length; i < _i; i++) ret[i] = data[i];
-        return ret.join('');
-    }
+    // function naive(data: string[]) {
+    //     let ret = '';
+    //     for (let i = 0, _i = data.length; i < _i; i++) ret += data[i];
+    //     return ret;
+    // }
+
+    // function join(data: string[]) {
+    //     let ret = [];
+    //     for (let i = 0, _i = data.length; i < _i; i++) ret[i] = data[i];
+    //     return ret.join('');
+    // }
 
     export function run() {
-        const data = createData(26 * 100000 * 2);
+        const data = createData(26 * 100000);
 
         const N = 512;
         const suite = new B.Suite();
         suite
-            .add(`naive`, () => naive(data)) // cras
-            .add(`join`, () => join(data))
+            // .add(`naive`, () => naive(data))
+            // .add(`join`, () => join(data))
             //.add(`${N} chunks`, () => SB.getChunks(build(data, N)))
             .add(`${N} str`, () => SB.getString(build(data, N)))
+            .add(`${N} str ws`, () => SB.getString(buildWS(data, N)))
             .on('cycle', (e: any) => console.log(String(e.target)))
             .run();
     }