chemaxon.marvin.io
Class MolImportModule

java.lang.Object
  chemaxon.marvin.io.MolImportModule

Direct Known Subclasses:

MolImport

public abstract class MolImportModule
extends java.lang.Object

Base class of Molecule import modules.

Example
I want to read a molecule from a file in a special format ("myformat") that stores the molecule name, the atom symbols, the x, y coordinates and the bond orders:

 Pyrrole
 5
 N -0.09625  2.75245
 C -1.42989  3.52245
 C -1.42989  5.06245
 C  1.23739  5.06245
 C  1.23739  3.52245
 5
 1 2 1
 2 3 2
 3 4 1
 4 5 2
 5 1 1
 

To read this file ("pyrrole.myf"), I create an import module for "myformat":

 package myio;
 
 import chemaxon.struc.*;
 import chemaxon.formats.MolInputStream;
 import chemaxon.formats.MolFormatException;
 import java.util.StringTokenizer;
 
 public class MyFormatImport extends chemaxon.marvin.io.MolImportModule
 {
     private MolInputStream istream;
 
     public void initMolImport(MolInputStream mis, String opts) {
         istream = mis;
     }
 
     public boolean readMol(Molecule mol) throws MolFormatException {
         // initialize molecule object
         mol.clearForImport("myformat");
         mol.setStartPosition(istream.getFilePointer());
 
         // read the molecule
         String line = istream.readLine();
         if(line == null) // end of file
             return false;
         mol.setName(line.trim()); // set molecule name
         mol.setDim(2);            // set number of dimensions
         try {
             line = istream.readLine();
             int numAtoms = Integer.parseInt(line.trim());
             for(int i = 0; i < numAtoms; ++i) {
                 line = istream.readLine();
                 StringTokenizer st = new StringTokenizer(line);
                 int atno = MolAtom.numOf(st.nextToken());
                 double x = Double.valueOf(st.nextToken()).doubleValue();
                 double y = Double.valueOf(st.nextToken()).doubleValue();
                 MolAtom a = mol.reuseAtom(atno, i);
                 a.setXY(x, y);
             }
             mol.endReuse(numAtoms);
             line = istream.readLine();
               int numBonds = Integer.parseInt(line.trim());
             for(int i = 0; i < numBonds; ++i) {
                 line = istream.readLine();
                 StringTokenizer st = new StringTokenizer(line);
                 int atomIndex1 = Integer.parseInt(st.nextToken()) - 1;
                 int atomIndex2 = Integer.parseInt(st.nextToken()) - 1;
                 int order = Integer.parseInt(st.nextToken());
                 MolBond b = new MolBond(mol.getAtom(atomIndex1),
                                         mol.getAtom(atomIndex2), order);
                 mol.add(b);
                 mol.valenceCheck(null); // to set the implicit hydrogens
             }
         } catch(NumberFormatException ex) {
             throw new MolFormatException("error in molecule file");
         }
 
         // memorize the last file position corresponding to this molecule
         mol.setEndPosition(istream.getFilePointer());
         return true;
     }
 
     public boolean createMol() {
         return new Molecule();
     }
 }
 

After compiling and placing the class into Marvin's CLASSPATH, I can read pyrrole.myf with Marvin applications,

 molconvert smiles "pyrrole.myf(myformat:)"

 msketch "pyrrole.myf(myformat:)"

 mview "pyrrole.myf(myformat:)"
 

and the applets:

 <param NAME="mol" VALUE="pyrrole.myf(myformat:)">

 msketch.setMol("pyrrole.myf(myformat:)");
 

Since:

Marvin 5.0, 09/07/2007

Version:

5.0, 09/07/2007

Author:

Peter Csizmadia

Constructor Summary

MolImportModule()

Method Summary

abstract Molecule	createMol() Creates a new target molecule object for the import.
abstract void	initMolImport(MolInputStream is) Initializes the import module.
boolean	isDocumentImporter() Tests whether this module is a document importer or not.
MDocument	readDocument(MDocument doc) Reads the next document.
abstract boolean	readMol(Molecule m) Reads the next molecule.
void	setOptions(java.lang.String options) Sets the import options.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MolImportModule

public MolImportModule()

Method Detail

setOptions

public void setOptions(java.lang.String options)

Sets the import options. The default implementation is empty.

Parameters:

options - import options

initMolImport

public abstract void initMolImport(MolInputStream is)
                            throws MolFormatException,
                                   java.io.IOException

Initializes the import module.

Parameters:

is - the molecule input stream

Throws:

MolFormatException - if the file cannot be read because of a molecule file format related error

java.io.IOException - an I/O error occured while reading the file

readMol

public abstract boolean readMol(Molecule m)
                         throws MolFormatException,
                                java.io.IOException

Reads the next molecule.

Returns:

true if reading was successful, false if there is nothing to read (EOF reached)

Throws:

MolFormatException - if the file cannot be read because of a molecule file format related error

java.io.IOException - an I/O error occured while reading the file

createMol

public abstract Molecule createMol()

Creates a new target molecule object for the import.

Since:

Marvin 3.4, 05/08/2004

isDocumentImporter

public boolean isDocumentImporter()

Tests whether this module is a document importer or not.

Returns:

true if it it is a document readers, false if it is a simple molecule reader

See Also:

readDocument(MDocument)

readDocument

public MDocument readDocument(MDocument doc)
                       throws java.io.IOException

Reads the next document. This method should only be called if isDocumentImporter() returns true.

Parameters:

doc - target document or null

Returns:

the target document object

Throws:

java.io.IOException - the file is in bad format or could not read

See Also:

isDocumentImporter()