edu.harvard.med.screensaver.io.libraries.WellsSdfDataExporter.java Source code

Introduction

Here is the source code for edu.harvard.med.screensaver.io.libraries.WellsSdfDataExporter.java

Source

// $HeadURL$
// $Id$
//
// Copyright  2006, 2010, 2011, 2012 by the President and Fellows of Harvard College.
//
// Screensaver is an open-source project developed by the ICCB-L and NSRB labs
// at Harvard Medical School. This software is distributed under the terms of
// the GNU General Public License.

package edu.harvard.med.screensaver.io.libraries;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import edu.harvard.med.screensaver.db.GenericEntityDAO;
import edu.harvard.med.screensaver.db.datafetcher.EntityDataFetcher;
import edu.harvard.med.screensaver.io.DataExporter;
import edu.harvard.med.screensaver.io.libraries.smallmolecule.LibraryContentsVersionReference;
import edu.harvard.med.screensaver.model.libraries.Gene;
import edu.harvard.med.screensaver.model.libraries.LibraryContentsVersion;
import edu.harvard.med.screensaver.model.libraries.Reagent;
import edu.harvard.med.screensaver.model.libraries.SilencingReagent;
import edu.harvard.med.screensaver.model.libraries.SmallMoleculeReagent;
import edu.harvard.med.screensaver.model.libraries.Well;
import edu.harvard.med.screensaver.model.meta.PropertyPath;
import edu.harvard.med.screensaver.model.meta.RelationshipPath;

public class WellsSdfDataExporter implements DataExporter<String> {
    private static final Logger log = Logger.getLogger(WellsSdfDataExporter.class);

    private static final int MAX_FETCH_SIZE = 1 << 8;

    private GenericEntityDAO _dao;

    private LibraryContentsVersionReference _libraryContentsVersionRef;

    /** for CGLIB2 */
    protected WellsSdfDataExporter() {
    }

    public WellsSdfDataExporter(GenericEntityDAO dao, LibraryContentsVersionReference libraryContentsVersionRef) {
        _dao = dao;
        _libraryContentsVersionRef = libraryContentsVersionRef;
    }

    @Transactional(readOnly = true, propagation = Propagation.NEVER) /* avoid accumulating entity objects in the Hibernate session, for scalability */
    public InputStream export(final Iterator<String> wellKeyStrs) throws IOException {
        WellSdfWriter writer = null;
        File outFile = null;
        try {
            outFile = File.createTempFile("wellsSdfDataExporter", "sdf");
            log.debug("creating temp file: " + outFile);
            outFile.deleteOnExit();
            FileWriter outWriter = new FileWriter(outFile);
            writer = new WellSdfWriter(new PrintWriter(outWriter));
            EntityDataFetcher<Well, String> dataFetcher = new EntityDataFetcher<Well, String>(Well.class, _dao);
            List<PropertyPath<Well>> relationships = Lists.newArrayList();
            relationships.add(Well.library.toFullEntity());
            relationships.add(Well.reagents.to(Reagent.publications).toFullEntity());
            RelationshipPath<Well> toReagentPath;
            if (getLibraryContentsVersion() == null) {
                toReagentPath = Well.latestReleasedReagent;
            } else {
                toReagentPath = Well.reagents.restrict("libraryContentsVersion", getLibraryContentsVersion());
            }
            relationships.add(toReagentPath.to(Reagent.libraryContentsVersion).toFullEntity());
            relationships.add(toReagentPath.to(SmallMoleculeReagent.compoundNames));
            relationships.add(toReagentPath.to(SmallMoleculeReagent.pubchemCids));
            relationships.add(toReagentPath.to(SmallMoleculeReagent.chembankIds));
            relationships.add(toReagentPath.to(SmallMoleculeReagent.chemblIds));
            relationships.add(toReagentPath.to(SmallMoleculeReagent.molfileList));
            relationships.add(toReagentPath.to(SilencingReagent.facilityGenes).to(Gene.genbankAccessionNumbers)
                    .toFullEntity());
            dataFetcher.setPropertiesToFetch(relationships);

            writeSDFileSearchResults(writer, Lists.newArrayList(wellKeyStrs), dataFetcher);
        } finally {
            IOUtils.closeQuietly(writer);
        }
        return new FileInputStream(outFile);
    }

    private LibraryContentsVersion getLibraryContentsVersion() {
        if (_libraryContentsVersionRef != null) {
            return _libraryContentsVersionRef.value();
        }
        return null;
    }

    public String getFileName() {
        return "wellSearchResults.sdf";
    }

    public String getFormatName() {
        return "SD File";
    }

    public String getMimeType() {
        return "chemical/x-mdl-sdfile";
    }

    private void writeSDFileSearchResults(WellSdfWriter writer, Collection<String> keys,
            EntityDataFetcher<Well, String> dataFetcher) {
        Iterable<List<String>> partitions = Iterables.partition(keys, MAX_FETCH_SIZE);
        for (Iterable<String> partition : partitions) {
            Map<String, Well> entities = dataFetcher.fetchData(Sets.newHashSet(partition));
            for (Well well : entities.values()) {
                if (well.getLibrary().getReagentType().equals(SmallMoleculeReagent.class)) {
                    writer.write(well, getLibraryContentsVersion());
                }
            }
        }
        // allow garbage collection
        _libraryContentsVersionRef.setValue(null);
    }
}