cleanup

src/servers/model/ligand-writer/ligand-encoder.ts

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Sebastian Bittrich <sebastian.bittrich@rcsb.org>
+ */
+
+import { StringBuilder } from '../../../mol-util';
+import Writer from '../../../mol-io/writer/writer';
+import { Encoder, Category } from '../../../mol-io/writer/cif/encoder';
+import { ComponentBond } from '../../../mol-model-formats/structure/property/bonds/comp';
+
+export abstract class LigandExplorer implements Encoder<string> {
+    protected builder: StringBuilder;
+    protected componentData: ComponentBond;
+    readonly isBinary = false;
+    binaryEncodingProvider = void 0;
+
+    abstract writeCategory<Ctx>(category: Category<Ctx>, context?: Ctx): void;
+
+    abstract encode(): void;
+
+    setComponentBondData(componentData: ComponentBond) {
+        this.componentData = componentData;
+    }
+
+    writeTo(stream: Writer) {
+        const chunks = StringBuilder.getChunks(this.builder);
+        for (let i = 0, _i = chunks.length; i < _i; i++) {
+            stream.writeString(chunks[i]);
+        }
+    }
+
+    getSize() {
+        return StringBuilder.getSize(this.builder);
+    }
+
+    getData() {
+        return StringBuilder.getString(this.builder);
+    }
+
+    protected skipHydrogen(label: string) {
+        if (this.hydrogens) {
+            return false;
+        }
+        return label.startsWith('H');
+    }
+
+    protected getLabel(s: string) {
+        return s.replace(/[^A-Z]+/g, '');
+    }
+
+    protected getSortedFields<Ctx>(instance: Category.Instance<Ctx>, names: string[]) {
+        return names.map(n => this.getField(instance, n));
+    }
+
+    protected getField<Ctx>(instance: Category.Instance<Ctx>, name: string) {
+        return instance.fields.find(f => f.name === name)!;
+    }
+
+    startDataBlock() {}
+
+    setFilter() {}
+
+    setFormatter() {}
+
+    isCategoryIncluded() {
+        return true;
+    }
+
+    constructor(readonly encoder: string, readonly hydrogens: boolean) {
+        this.builder = StringBuilder.create();
+    }
+}

src/servers/model/ligand-writer/mol.ts

@@ -16,6 +16,6 @@ export namespace MolWriter {
 
     export function createEncoder(params?: EncoderParams): Encoder {
         const { encoderName = 'mol*', hydrogens = false } = params || {};
-        return new MolEncoder(encoderName, false, hydrogens, '');
+        return new MolEncoder(encoderName, false, hydrogens);
     }
 }

src/servers/model/ligand-writer/mol/encoder.ts

@@ -5,45 +5,17 @@
  */
 
 import { StringBuilder, deepEqual } from '../../../../mol-util';
-import Writer from '../../../../mol-io/writer/writer';
-import { Encoder, Category, Field } from '../../../../mol-io/writer/cif/encoder';
+import { Category, Field } from '../../../../mol-io/writer/cif/encoder';
 import { getCategoryInstanceData } from '../../../../mol-io/writer/cif/encoder/util';
-import { ComponentBond } from '../../../../mol-model-formats/structure/property/bonds/comp';
+import { LigandExplorer } from '../ligand-encoder';
 
 // specification: http://c4.cabrillo.edu/404/ctfile.pdf
 // SDF wraps MOL and allows for multiple molecules per file as well as additional properties
 // TODO add support for stereo/chiral flags, add charges
-export class MolEncoder implements Encoder<string> {
-    private builder: StringBuilder;
+export class MolEncoder extends LigandExplorer {
     private meta: StringBuilder;
     private encoded = false;
     private error = false;
-    private componentData: ComponentBond;
-    readonly isBinary = false;
-    binaryEncodingProvider = void 0;
-
-    setComponentBondData(componentData: ComponentBond) {
-        this.componentData = componentData;
-    }
-
-    writeTo(stream: Writer) {
-        const chunks = StringBuilder.getChunks(this.builder);
-        for (let i = 0, _i = chunks.length; i < _i; i++) {
-            stream.writeString(chunks[i]);
-        }
-    }
-
-    getSize() {
-        return StringBuilder.getSize(this.builder);
-    }
-
-    getData() {
-        return StringBuilder.getString(this.builder);
-    }
-
-    startDataBlock() {
-
-    }
 
     writeCategory<Ctx>(category: Category<Ctx>, context?: Ctx) {
         if (this.encoded) {
@@ -120,7 +92,7 @@ export class MolEncoder implements Encoder<string> {
     private getAtoms(source: any, fields: Field<any, any>[], label_atom_id: Field<any, any>, auxiliaryFields: Field<any, any>[], ctab: StringBuilder): string[] {
         const atoms = [];
         let index = 0;
-        let id: (string | number)[];
+        let id: (string | number)[] | undefined = void 0;
 
         // is outer loop even needed?
         l: for (let _c = 0; _c < source.length; _c++) {
@@ -165,17 +137,6 @@ export class MolEncoder implements Encoder<string> {
         return atoms;
     }
 
-    private skipHydrogen(label: string) {
-        if (this.hydrogens) {
-            return false;
-        }
-        return label.startsWith('H');
-    }
-
-    private getLabel(s: string) {
-        return s.replace(/[^A-Z]+/g, '');
-    }
-
     private writeFullCategory<Ctx>(sb: StringBuilder, category: Category<Ctx>, context?: Ctx) {
         const { instance, source } = getCategoryInstanceData(category, context);
         const fields = instance.fields;
@@ -207,14 +168,6 @@ export class MolEncoder implements Encoder<string> {
         }
     }
 
-    private getSortedFields<Ctx>(instance: Category.Instance<Ctx>, names: string[]) {
-        return names.map(n => this.getField(instance, n));
-    }
-
-    private getField<Ctx>(instance: Category.Instance<Ctx>, name: string) {
-        return instance.fields.find(f => f.name === name)!;
-    }
-
     encode() {
         // write meta-information, do so after ctab
         if (this.error || this.metaInformation) {
@@ -229,20 +182,12 @@ export class MolEncoder implements Encoder<string> {
         this.encoded = true;
     }
 
-    setFilter() {}
-
-    setFormatter() {}
-
-    isCategoryIncluded() {
-        return true;
-    }
+    constructor(readonly encoder: string, readonly metaInformation: boolean, readonly hydrogens: boolean, readonly terminator: string = '') {
+        super(encoder, hydrogens);
 
-    constructor(readonly encoder: string, readonly metaInformation: boolean, readonly hydrogens: boolean, readonly terminator: string) {
         if (metaInformation && !!terminator) {
             throw new Error('meta-information cannot be written for MOL files');
         }
-        
-        this.builder = StringBuilder.create();
         this.meta = StringBuilder.create();
     }
 }

src/servers/model/ligand-writer/mol2/encoder.ts

@@ -4,8 +4,34 @@
  * @author Sebastian Bittrich <sebastian.bittrich@rcsb.org>
  */
 
-import { Encoder } from "../../../../mol-io/writer/cif/encoder";
+import { Category } from "../../../../mol-io/writer/cif/encoder";
+import { LigandExplorer } from "../ligand-encoder";
+import { StringBuilder } from "../../../../mol-util";
 
 // specification: http://chemyang.ccnu.edu.cn/ccb/server/AIMMS/mol2.pdf
-export class Mol2Encoder implements Encoder<string> {
+export class Mol2Encoder extends LigandExplorer {
+    private meta: StringBuilder;
+    private encoded = false;
+    private error = false;
+
+    writeCategory<Ctx>(category: Category<Ctx>, context?: Ctx): void {
+        if (this.encoded) {
+            throw new Error('The writer contents have already been encoded, no more writing.');
+        }
+
+    }
+
+    encode(): void {
+        // write meta-information, do so after ctab
+        if (this.error || this.metaInformation) {
+            StringBuilder.writeSafe(this.builder, StringBuilder.getString(this.meta));
+        }
+
+        this.encoded = true;
+    }
+
+    constructor(readonly encoder: string, readonly metaInformation: boolean, readonly hydrogens: boolean) {
+        super(encoder, hydrogens);
+        this.meta = StringBuilder.create();
+    }
 }

src/servers/model/server/query.ts

@@ -7,8 +7,6 @@
 import * as path from 'path';
 import { Column } from '../../../mol-data/db';
 import { CifWriter } from '../../../mol-io/writer/cif';
-import { SdfWriter } from '../../../mol-io/writer/sdf';
-import { Mol2Writer } from '../../../mol-io/writer/mol2';
 import { Structure, StructureQuery, StructureSelection } from '../../../mol-model/structure';
 import { encode_mmCIF_categories } from '../../../mol-model/structure/export/mmcif';
 import { Progress } from '../../../mol-task';
@@ -25,8 +23,11 @@ import { splitCamelCase } from '../../../mol-util/string';
 import { Encoder } from '../../../mol-io/writer/cif/encoder';
 import { Encoding } from './api';
 import { ComponentBond } from '../../../mol-model-formats/structure/property/bonds/comp';
-import { SdfEncoder } from '../../../mol-io/writer/sdf/encoder';
-import { Mol2Encoder } from '../../../mol-io/writer/mol2/encoder';
+import { SdfWriter } from '../ligand-writer/sdf';
+import { MolWriter } from '../ligand-writer/mol';
+import { Mol2Writer } from '../ligand-writer/mol2';
+import { MolEncoder } from '../ligand-writer/mol/encoder';
+import { Mol2Encoder } from '../ligand-writer/mol2/encoder';
 
 export interface Stats {
     structure: StructureWrapper,
@@ -71,7 +72,7 @@ function createEncoder(job: Job): Encoder {
             });
         case 'mol':
             ensureCompatibleQueryType(job);
-            return Mol2Writer.createEncoder({
+            return MolWriter.createEncoder({
                 ...SharedParams
             })
         case 'mol2':
@@ -220,7 +221,7 @@ async function resolveJobEntry(entry: JobEntry, structure: StructureWrapper, enc
         encoder.writeCategory(_model_server_result, entry);
         encoder.writeCategory(_model_server_params, entry);
 
-        if (encoder instanceof SdfEncoder || encoder instanceof Mol2Encoder) encoder.setComponentBondData(ComponentBond.Provider.get(structure.models[0])!);
+        if (encoder instanceof MolEncoder || encoder instanceof Mol2Encoder) encoder.setComponentBondData(ComponentBond.Provider.get(structure.models[0])!);
         if (!entry.copyAllCategories && entry.queryDefinition.filter) encoder.setFilter(entry.queryDefinition.filter);
         if (result.length > 0) encode_mmCIF_categories(encoder, result, { copyAllCategories: entry.copyAllCategories });
         if (!entry.copyAllCategories && entry.queryDefinition.filter) encoder.setFilter();