001/* 002 * BioJava development code 003 * 004 * This code may be freely distributed and modified under the 005 * terms of the GNU Lesser General Public Licence. This should 006 * be distributed with the code. If you do not have a copy, 007 * see: 008 * 009 * http://www.gnu.org/copyleft/lesser.html 010 * 011 * Copyright for this code is held jointly by the individual 012 * authors. These should be listed in @author doc comments. 013 * 014 * For more information on the BioJava project and its aims, 015 * or to join the biojava-l mailing list, visit the home page 016 * at: 017 * 018 * http://www.biojava.org/ 019 * 020 * Created on DATE 021 * 022 */ 023package org.biojava.nbio.core.sequence; 024 025import org.biojava.nbio.core.exceptions.CompoundNotFoundException; 026import org.biojava.nbio.core.sequence.compound.DNACompoundSet; 027import org.biojava.nbio.core.sequence.compound.NucleotideCompound; 028import org.biojava.nbio.core.sequence.loader.StringProxySequenceReader; 029import org.biojava.nbio.core.sequence.template.*; 030import org.biojava.nbio.core.sequence.transcription.Frame; 031import org.biojava.nbio.core.sequence.transcription.TranscriptionEngine; 032import org.biojava.nbio.core.sequence.views.ComplementSequenceView; 033import org.biojava.nbio.core.sequence.views.ReversedSequenceView; 034import org.slf4j.Logger; 035import org.slf4j.LoggerFactory; 036 037/** 038 * This is class should model the attributes associated with a DNA sequence 039 * 040 * @author Scooter Willis 041 */ 042public class DNASequence extends AbstractSequence<NucleotideCompound> { 043 044 private final static Logger logger = LoggerFactory.getLogger(DNASequence.class); 045/** 046 * The type of DNA sequence 047 */ 048 public enum DNAType { 049 CHROMOSOME, MITOCHONDRIAL, PLASMID, PLASTID, UNKNOWN 050 } 051 private DNAType dnaType = DNAType.UNKNOWN; 052 053 /** 054 * Shouldn't be used but makes it bean happy 055 */ 056 public DNASequence() { 057// throw new UnsupportedOperationException("Null constructor not supported"); 058 } 059 060 /** 061 * String is king and create a sequence from DNA with default DNA compound set 062 * @param seqString 063 * @throws CompoundNotFoundException 064 */ 065 public DNASequence(String seqString) throws CompoundNotFoundException { 066 super(seqString, DNACompoundSet.getDNACompoundSet()); 067 } 068 069 /** 070 * Create a sequence where the actual storage of the sequence data is somewhere else 071 * @param proxyLoader 072 */ 073 public DNASequence(SequenceReader<NucleotideCompound> proxyLoader) { 074 super(proxyLoader, DNACompoundSet.getDNACompoundSet()); 075 } 076 077 /** 078 * Create a sequence from a string with user defined compound set 079 * @param seqString 080 * @param compoundSet 081 * @throws CompoundNotFoundException 082 */ 083 public DNASequence(String seqString, CompoundSet<NucleotideCompound> compoundSet) throws CompoundNotFoundException { 084 super(seqString, compoundSet); 085 } 086 087 /** 088 * Create a sequence from a ProxySequencereader and user defined compound set 089 * @param proxyLoader 090 * @param compoundSet 091 */ 092 public DNASequence(SequenceReader<NucleotideCompound> proxyLoader, CompoundSet<NucleotideCompound> compoundSet) { 093 super(proxyLoader, compoundSet); 094 } 095 096 /** 097 * Return the RNASequence equivalent of the DNASequence using default Transcription Engine. Not all 098 * species follow the same rules. If you don't know better use this method 099 * @return RNA sequence 100 */ 101 public RNASequence getRNASequence() { 102 return getRNASequence(Frame.getDefaultFrame()); 103 } 104 105 /** 106 * Allow a user to pass in a rules engine to do the DNA to RNA translation 107 * @param engine 108 * @return RNA sequence 109 */ 110 public RNASequence getRNASequence(TranscriptionEngine engine) { 111 return getRNASequence(engine, Frame.getDefaultFrame()); 112 } 113 114 /** 115 * Allows the user to pass in the Frame shift. 116 * @param frame 117 * @return rna sequence 118 */ 119 public RNASequence getRNASequence(Frame frame) { 120 return getRNASequence(TranscriptionEngine.getDefault(), frame); 121 } 122 123 public RNASequence getRNASequence(TranscriptionEngine engine, Frame frame) { 124 return (RNASequence) engine.getDnaRnaTranslator().createSequence(this, frame); 125 } 126 127 /** 128 * Get the GC count in the DNA Sequence 129 * @return GC count 130 */ 131 public int getGCCount() { 132 return SequenceMixin.countGC(this); 133 } 134 135 /** 136 * Returns a Sequence which runs in the current reverse order 137 */ 138 public SequenceView<NucleotideCompound> getReverse() { 139 return new ReversedSequenceView<NucleotideCompound>(this); 140 } 141 142 /** 143 * Returns a Sequence which will complement every base 144 */ 145 public SequenceView<NucleotideCompound> getComplement() { 146 return new ComplementSequenceView<NucleotideCompound>(this); 147 } 148 149 /** 150 * Delegates to {@link #getInverse() } for the reverse complement 151 */ 152 public SequenceView<NucleotideCompound> getReverseComplement() { 153 return getInverse(); 154 } 155 156 /** 157 * @return the dnaType 158 */ 159 public DNAType getDNAType() { 160 return dnaType; 161 } 162 163 /** 164 * @param dnaType the dnaType to set 165 */ 166 public void setDNAType(DNAType dnaType) { 167 this.dnaType = dnaType; 168 } 169 170 public static void main(String[] args) throws Exception { 171 DNASequence dnaSequence = new DNASequence("ATCG"); 172 logger.info("DNA Sequence: {}", dnaSequence.toString()); 173 174 StringProxySequenceReader<NucleotideCompound> sequenceStringProxyLoader = 175 new StringProxySequenceReader<NucleotideCompound>("GCTA", DNACompoundSet.getDNACompoundSet()); 176 DNASequence dnaSequenceFromProxy = new DNASequence(sequenceStringProxyLoader); 177 logger.info("DNA Sequence from Proxy: {}", dnaSequenceFromProxy.toString()); 178 } 179}