Have basics, but formatting is not complete because of unclearness. Not using computations, wait, async, promise. And small fix

src/reader/mol2/parser.ts

@@ -3,7 +3,9 @@ import FixedColumn from '../common/text/column/fixed'
 import { ColumnType, UndefinedColumn } from '../common/column'
 import * as Schema from './schema'
 import Result from '../result'
-//import Computation from '../../utils/computation'
+import Computation from '../../utils/computation' ////////// not using this
+
+
 
 interface State {
     tokenizer: Tokenizer,
@@ -11,6 +13,8 @@ interface State {
     ///////////// not including Computation.chunker /////////////
 }
 
+
+
 function createEmptyMolecule(): Schema.Molecule {
     return {
         mol_name: '',
@@ -26,6 +30,9 @@ function createEmptyMolecule(): Schema.Molecule {
     };
 }
 
+
+
+
 function State(tokenizer: Tokenizer): State { //////////// not having ctx: Computation.Context as a parameter //////////////
     return {
         tokenizer,
@@ -34,9 +41,10 @@ function State(tokenizer: Tokenizer): State { //////////// not having ctx: Compu
     };
 }
 
-/**
- * title string (free format string, optional time in ps after 't=')
- */
+
+
+
+
 function handleMolecule(state: State) {
     const { tokenizer, molecule } = state;
     
@@ -63,74 +71,122 @@ function handleMolecule(state: State) {
 
 }
 
-/**
- * This format is fixed, ie. all columns are in a fixed position.
- * Optionally (for now only yet with trjconv) you can write gro files
- * with any number of decimal places, the format will then be n+5
- * positions with n decimal places (n+1 for velocities) in stead
- * of 8 with 3 (with 4 for velocities). Upon reading, the precision
- * will be inferred from the distance between the decimal points
- * (which will be n+5). Columns contain the following information
- * (from left to right):
- *     residue number (5 positions, integer)
- *     residue name (5 characters)
- *     atom name (5 characters)
- *     atom number (5 positions, integer)
- *     position (in nm, x y z in 3 columns, each 8 positions with 3 decimal places)
- *     velocity (in nm/ps (or km/s), x y z in 3 columns, each 8 positions with 4 decimal places)
- */
+
+
+
+
 function handleAtoms(state: State): Schema.Atoms {
     const { tokenizer, molecule } = state;
 
     ////////// not using readLinesAsync /////////
     const lines =  Tokenizer.readLines(tokenizer, molecule.num_atoms);
 
+    // default all false
+    const hasSubst_id = false;
+    const hasSubst_name = false;
+    const hasCharge = false;
+    const hasStatus_bit = false;
+
+    /*
     const pO = 20;
     const pW = state.header.precision.position + 5;
     const vO = pO + 3 * pW;
     const vW = state.header.precision.velocity + 4;
+    */
+
+    const col = FixedColumn(lines);
+    const undefInt = UndefinedColumn(molecule.num_atoms, ColumnType.int);
+    const undefFloat = UndefinedColumn(molecule.num_atoms, ColumnType.float);
+    const undefStr = UndefinedColumn(molecule.num_atoms, ColumnType.str);
+    const undefPooledStr = UndefinedColumn(molecule.num_atoms, ColumnType.pooledStr);
 
-    const col = FixedColumn({ data: tokenizer.data, lines, rowCount: state.numberOfAtoms });
+    /////// wanted to have const undef = UndefinedColumn(molecule.num_atoms) like col, but failed
 
+    /////// some unclear about the formatting, like the field sizes
     const ret = {
         count: molecule.num_atoms,
-        atom_id: col(0, 0, ColumnType.int),
-        atom_name: col(0, 0, ColumnType.str),
-        x: col(0, 0, ColumnType.float),
+        atom_id: col(0, 7, ColumnType.int),
+        atom_name: col(7, 9, ColumnType.str), ////// don't know use str or pooledStr
+        x: col(16, 10, ColumnType.float),
+        y: col(26, 10, ColumnType.float),
+        z: col(36, 10, ColumnType.float),
+        atom_type: col(46, 0, ColumnType.str), ////// don't know use str or pooledStr //////// don't know which is the atom_type
+        // optional properties
+        subst_id: hasSubst_id ? col(0, 0, ColumnType.int) : undefInt, 
+        subst_name: hasSubst_name ? col(0, 0, ColumnType.str) : undefStr,///////// don't know use str or pooledStr
+        charge: hasCharge ? col(0, 0, ColumnType.float) : undefFloat, //////// don't know use int or float
+        status_bit: hasStatus_bit ? col(0, 0, ColumnType.pooledStr) : undefPooledStr, ////////// don't know use str or pooledStr
     };
 
     return ret;
 }
 
-/**
- * box vectors (free format, space separated reals), values:
- * v1(x) v2(y) v3(z) v1(y) v1(z) v2(x) v2(z) v3(x) v3(y),
- * the last 6 values may be omitted (they will be set to zero).
- * Gromacs only supports boxes with v1(y)=v1(z)=v2(z)=0.
- */
-function handleBoxVectors(state: State) {
-    const { tokenizer } = state;
-    markLine(tokenizer);
-    const values = getTokenString(tokenizer).trim().split(/\s+/g);
-    state.header.box = [+values[0], +values[1], +values[2]];
+
+
+
+function handleBonds(state: State): Schema.Bonds {
+    const { tokenizer, molecule } = state;
+
+    ////////// not using readLinesAsync /////////
+    const lines =  Tokenizer.readLines(tokenizer, molecule.num_bonds);
+
+    // default all false
+    const hasStatus_bit = false;
+
+    /*
+    const pO = 20;
+    const pW = state.header.precision.position + 5;
+    const vO = pO + 3 * pW;
+    const vW = state.header.precision.velocity + 4;
+    */
+
+    const col = FixedColumn(lines);
+    const undefInt = UndefinedColumn(molecule.num_bonds, ColumnType.int);
+    const undefFloat = UndefinedColumn(molecule.num_bonds, ColumnType.float);
+    const undefStr = UndefinedColumn(molecule.num_bonds, ColumnType.str);
+    const undefPooledStr = UndefinedColumn(molecule.num_bonds, ColumnType.pooledStr);
+
+    /////// wanted to have const undef = UndefinedColumn(molecule.num_atoms) like col, but failed
+
+    /////// some unclear about the formatting, like the field sizes
+    const ret = {
+        count: molecule.num_bonds,
+        bond_id: col(0, 6, ColumnType.int),
+        origin_atom_id: col(6, 6, ColumnType.int), 
+        target_atom_id: col(12, 6, ColumnType.int),
+        bond_type: col(18, 5, ColumnType.str), ///////// don't know use str or pooledStr
+        // optional properties
+        status_bits: hasStatus_bit ? col(0, 0, ColumnType.str) : undefStr, ///////// don't know use str or pooledStr
+    };
+
+    return ret;
 }
 
-function parseInternal(data: string): Result<Schema.File> {
-    const tokenizer = TokenizerState(data);
+
+
+
+//////// not using async here
+function parseInternal(data: string): Result<Schema.File> { /////// not having ctx as a parameter, and not returning Promise
+    const tokenizer = Tokenizer(data);
 
     const structures: Schema.Structure[] = [];
     while (tokenizer.position < data.length) {
-        const state = createState(tokenizer);
+        const state = State(tokenizer);//////////different
         handleMolecule(state);
         const atoms = handleAtoms(state);
-        handleBoxVectors(state);
-        structures.push({ header: state.header, atoms });
+        const bonds = handleBonds(state);
+        structures.push({ molecule: state.molecule, atoms, bonds });
     }
 
     const result: Schema.File = { structures };
     return Result.success(result);
 }
 
+
+
+
+
+///////// diffrent than gro parser
 export function parse(data: string) {
     return parseInternal(data);
 }