Package chemaxon.marvin.io

Class MolImportModule

java.lang.Object
chemaxon.marvin.io.MolImportModule
Direct Known Subclasses:
MolImport
@PublicApi public abstract class MolImportModule extends 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) {
         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

  • Constructor Details

    • MolImportModule

      public MolImportModule()

  • Method Details

    • setOptions

      public void setOptions(String options) throws IllegalArgumentException
      Sets the import options. The default implementation is empty.
      Parameters:
      options - import options
      Throws:
      IllegalArgumentException - if the specified options cannot be interpreted by the import module

    • initMolImport

      public void initMolImport(MRecord record, String fname) throws IOException
      Initializes the import module. By default, it calls initMolImport(chemaxon.formats.MolInputStream) with the input stream generated from the molecule string stored in the specified molecule record. Subclasses should override either this method (if the import uses data fields in MRecord) or else initMolImport(chemaxon.formats.MolInputStream).
      Parameters:
      record - the molecule record
      fname - the input filename or URL
      Throws:
      MolFormatException - if the file cannot be read because of a molecule file format related error
      IOException - an I/O error occurred while reading the file
      Since:
      Marvin 5.3

    • initMolImport

      public void initMolImport(MolInputStream is) throws IOException
      Initializes the import module. The default implementation is empty. Subclasses should override either this method or else initMolImport(MRecord, String) )} if the import uses other fields in MRecord.
      Parameters:
      is - the molecule input stream
      Throws:
      MolFormatException - if the file cannot be read because of a molecule file format related error
      IOException - an I/O error occurred while reading the file

    • readMol

      public abstract boolean readMol(Molecule m) throws 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
      IOException - an I/O error occurred 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

      public MDocument readDocument(MDocument doc) throws 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:
      IOException - the file is in bad format or could not read
      See Also:

    • getLineCount

      public int getLineCount()
      Returns the line count in the molecule input stream.
      Returns:
      the line count in the molecule input stream
      Since:
      Marvin 5.3

    • getPreferredView

      public MolImportModule.PreferredView getPreferredView()
      Specifies which view style is preferred (for instance in MarvinView) for this format.