Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
FileParse	56	231	101	0.00%	Show methods

Class FileParse

Class FileParse	Line # 56	Total Statements 231	Complexity 101	TOTAL Coverage 0.00%
getBytes() : byte[]   getBytes() : byte[]	7171	1.01	1.01	0.0 0.00%
setNewlineString(String) : void   setNewlineString(String) : void	103103	1.01	1.01	0.0 0.00%
getNewlineString() : String   getNewlineString() : String	108108	1.01	1.01	0.0 0.00%
FileParse()   FileParse()	134134	0.00	1.01	-1.0 -1.0 -
FileParse(FileParse)   FileParse(FileParse)	145145	15.015	4.04	0.0 0.00%
checkFileSource(String) : boolean   checkFileSource(String) : boolean	178178	19.019	6.06	0.0 0.00%
isGzipStream(InputStream) : boolean   isGzipStream(InputStream) : boolean	228228	11.011	3.03	0.0 0.00%
checkForGzipStream(InputStream) : BufferedReader   checkForGzipStream(InputStream) : BufferedReader	258258	7.07	3.03	0.0 0.00%
getGzipReader(InputStream) : BufferedReader   getGzipReader(InputStream) : BufferedReader	287287	5.05	1.01	0.0 0.00%
checkURLSource(String) : void   checkURLSource(String) : void	315315	29.029	7.07	0.0 0.00%
extractSuffix(String) : String   extractSuffix(String) : String	382382	5.05	3.03	0.0 0.00%
FileParse(BufferedReader,String,DataSourceType)   FileParse(BufferedReader,String,DataSourceType)	399399	8.08	3.03	0.0 0.00%
FileParse(Object,DataSourceType)   FileParse(Object,DataSourceType)	430430	3.03	2.02	0.0 0.00%
parse(File,String,DataSourceType,boolean) : void   parse(File,String,DataSourceType,boolean) : void	443443	62.062	28.028	0.0 0.00%
mark() : void   mark() : void	600600	3.03	2.02	0.0 0.00%
nextLine() : String   nextLine() : String	613613	3.03	2.02	0.0 0.00%
isExporting() : boolean   isExporting() : boolean	628628	1.01	1.01	0.0 0.00%
isValid() : boolean   isValid() : boolean	637637	1.01	1.01	0.0 0.00%
close() : void   close() : void	645645	5.05	1.01	0.0 0.00%
reset(int) : void   reset(int) : void	660660	5.05	4.04	0.0 0.00%
hasWarningMessage() : boolean   hasWarningMessage() : boolean	683683	1.01	1.01	0.0 0.00%
getWarningMessage() : String   getWarningMessage() : String	692692	1.01	1.01	0.0 0.00%
getInFile() : String   getInFile() : String	697697	3.03	2.02	0.0 0.00%
getDataName() : String   getDataName() : String	712712	1.01	1.01	0.0 0.00%
setDataName(String) : void   setDataName(String) : void	722722	1.01	1.01	0.0 0.00%
getReader() : Reader   getReader() : Reader	733733	3.03	2.02	0.0 0.00%
getViewport() : AlignViewportI   getViewport() : AlignViewportI	743743	1.01	1.01	0.0 0.00%
setViewport(AlignViewportI) : void   setViewport(AlignViewportI) : void	748748	1.01	1.01	0.0 0.00%
getExportSettings() : AlignExportSettingsI   getExportSettings() : AlignExportSettingsI	756756	1.01	1.01	0.0 0.00%
setExportSettings(AlignExportSettingsI) : void   setExportSettings(AlignExportSettingsI) : void	767767	1.01	1.01	0.0 0.00%
configureForView(AlignmentViewPanel) : void   configureForView(AlignmentViewPanel) : void	778778	2.02	2.02	0.0 0.00%
getFeatureColourScheme() : FeatureSettingsModelI   getFeatureColourScheme() : FeatureSettingsModelI	793793	1.01	1.01	0.0 0.00%
getDataSourceType() : DataSourceType   getDataSourceType() : DataSourceType	798798	1.01	1.01	0.0 0.00%
getBufferedReader(Object,DataSourceType) : BufferedReader   getBufferedReader(Object,DataSourceType) : BufferedReader	813813	28.028	10.010	0.0 0.00%

 

Contributing tests

Source view

1		/*
2		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3		* Copyright (C) $$Year-Rel$$ The Jalview Authors
4		*
5		* This file is part of Jalview.
6		*
7		* Jalview is free software: you can redistribute it and/or
8		* modify it under the terms of the GNU General Public License
9		* as published by the Free Software Foundation, either version 3
10		* of the License, or (at your option) any later version.
11		*
12		* Jalview is distributed in the hope that it will be useful, but
13		* WITHOUT ANY WARRANTY; without even the implied warranty
14		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15		* PURPOSE. See the GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19		* The Jalview Authors are detailed in the 'AUTHORS' file.
20		*/
21		package jalview.io;
22
23		import java.io.BufferedInputStream;
24		import java.io.BufferedReader;
25		import java.io.ByteArrayInputStream;
26		import java.io.File;
27		import java.io.FileInputStream;
28		import java.io.FileNotFoundException;
29		import java.io.FileReader;
30		import java.io.IOException;
31		import java.io.InputStream;
32		import java.io.InputStreamReader;
33		import java.io.Reader;
34		import java.io.StringReader;
35		import java.net.HttpURLConnection;
36		import java.net.MalformedURLException;
37		import java.net.SocketTimeoutException;
38		import java.net.URL;
39		import java.net.URLConnection;
40		import java.net.UnknownHostException;
41		import java.util.zip.GZIPInputStream;
42
43		import jalview.api.AlignExportSettingsI;
44		import jalview.api.AlignViewportI;
45		import jalview.api.AlignmentViewPanel;
46		import jalview.api.FeatureSettingsModelI;
47		import jalview.bin.Console;
48		import jalview.util.HttpUtils;
49		import jalview.util.MessageManager;
50		import jalview.util.Platform;
51
52		/**
53		* implements a random access wrapper around a particular datasource, for
54		* passing to identifyFile and AlignFile objects.
55		*/
		0% Uncovered Elements: 359 (359) Complexity: 101 Complexity Density: 0.44
56		public class FileParse
57		{
58		protected static final String SPACE = " ";
59
60		protected static final String TAB = "\t";
61
62		/**
63		* text specifying source of data. usually filename or url.
64		*/
65		private String dataName = "unknown source";
66
67		public File inFile = null;
68
69		private byte[] bytes; // from JavaScript
70
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
71	0	public byte[] getBytes()...
72		{
73	0	return bytes;
74		}
75
76		/**
77		* a viewport associated with the current file operation. May be null. May
78		* move to different object.
79		*/
80		private AlignViewportI viewport;
81
82		/**
83		* specific settings for exporting data from the current context
84		*/
85		private AlignExportSettingsI exportSettings;
86
87		/**
88		* sequence counter for FileParse object created from same data source
89		*/
90		public int index = 1;
91
92		/**
93		* separator for extracting specific 'frame' of a datasource for formats that
94		* support multiple records (e.g. BLC, Stockholm, etc)
95		*/
96		protected char suffixSeparator = '#';
97
98		/**
99		* character used to write newlines
100		*/
101		protected String newline = System.getProperty("line.separator");
102
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
103	0	public void setNewlineString(String nl)...
104		{
105	0	newline = nl;
106		}
107
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
108	0	public String getNewlineString()...
109		{
110	0	return newline;
111		}
112
113		/**
114		* '#' separated string tagged on to end of filename or url that was clipped
115		* off to resolve to valid filename
116		*/
117		protected String suffix = null;
118
119		protected DataSourceType dataSourceType = null;
120
121		protected BufferedReader dataIn = null;
122
123		protected String errormessage = "UNINITIALISED SOURCE";
124
125		protected boolean error = true;
126
127		protected String warningMessage = null;
128
129		/**
130		* size of readahead buffer used for when initial stream position is marked.
131		*/
132		final int READAHEAD_LIMIT = 2048;
133
		- Uncovered Elements: 0 (0) Complexity: 1 Complexity Density: -
134	0	public FileParse()...
135		{
136		}
137
138		/**
139		* Create a new FileParse instance reading from the same datasource starting
140		* at the current position. WARNING! Subsequent reads from either object will
141		* affect the read position of the other, but not the error state.
142		*
143		* @param from
144		*/
		0% Uncovered Elements: 21 (21) Complexity: 4 Complexity Density: 0.27
145	0	public FileParse(FileParse from) throws IOException...
146		{
147	0	if (from == null)
148		{
149	0	throw new Error(MessageManager
150		.getString("error.implementation_error_null_fileparse"));
151		}
152	0	if (from == this)
153		{
154	0	return;
155		}
156	0	index = ++from.index;
157	0	inFile = from.inFile;
158	0	suffixSeparator = from.suffixSeparator;
159	0	suffix = from.suffix;
160	0	errormessage = from.errormessage; // inherit potential error messages
161	0	error = false; // reset any error condition.
162	0	dataSourceType = from.dataSourceType;
163	0	dataIn = from.dataIn;
164	0	if (dataIn != null)
165		{
166	0	mark();
167		}
168	0	dataName = from.dataName;
169		}
170
171		/**
172		* Attempt to open a file as a datasource. Sets error and errormessage if
173		* fileStr was invalid.
174		*
175		* @param fileStr
176		* @return this.error (true if the source was invalid)
177		*/
		0% Uncovered Elements: 27 (27) Complexity: 6 Complexity Density: 0.32
178	0	private boolean checkFileSource(String fileStr) throws IOException...
179		{
180	0	error = false;
181	0	this.inFile = new File(fileStr);
182		// check to see if it's a Jar file in disguise.
183	0	if (!inFile.exists())
184		{
185	0	errormessage = "FILE NOT FOUND";
186	0	error = true;
187		}
188	0	if (!inFile.canRead())
189		{
190	0	errormessage = "FILE CANNOT BE OPENED FOR READING";
191	0	error = true;
192		}
193	0	if (inFile.isDirectory())
194		{
195		// this is really a 'complex' filetype - but we don't handle directory
196		// reads yet.
197	0	errormessage = "FILE IS A DIRECTORY";
198	0	error = true;
199		}
200	0	if (!error)
201		{
202	0	try
203		{
204	0	dataIn = checkForGzipStream(new FileInputStream(fileStr));
205	0	dataName = fileStr;
206		} catch (Exception x)
207		{
208	0	warningMessage = "Failed to resolve " + fileStr
209		+ " as a data source. (" + x.getMessage() + ")";
210		// x.printStackTrace();
211	0	error = true;
212		}
213	0	;
214		}
215	0	return error;
216		}
217
218		/**
219		* Recognise the 2-byte magic header for gzip streams
220		*
221		* https://recalll.co/ask/v/topic/java-How-to-check-if-InputStream-is-Gzipped/555aadd62bd27354438b90f6
222		*
223		* @param bytes
224		* - at least two bytes
225		* @return
226		* @throws IOException
227		*/
		0% Uncovered Elements: 15 (15) Complexity: 3 Complexity Density: 0.27
228	0	public static boolean isGzipStream(InputStream input) throws IOException...
229		{
230	0	if (!input.markSupported())
231		{
232	0	Console.error(
233		"FileParse.izGzipStream: input stream must support mark/reset");
234	0	return false;
235		}
236	0	input.mark(4);
237
238		// get first 2 bytes or return false
239	0	byte[] bytes = new byte[2];
240	0	int read = input.read(bytes);
241	0	input.reset();
242	0	if (read != bytes.length)
243		{
244	0	return false;
245		}
246
247	0	int header = (bytes[0] & 0xff) | ((bytes[1] << 8) & 0xff00);
248	0	return (GZIPInputStream.GZIP_MAGIC == header);
249		}
250
251		/**
252		* Returns a Reader for the given input after wrapping it in a buffered input
253		* stream, and then checking if it needs to be wrapped by a GZipInputStream
254		*
255		* @param input
256		* @return
257		*/
		0% Uncovered Elements: 11 (11) Complexity: 3 Complexity Density: 0.43
258	0	private BufferedReader checkForGzipStream(InputStream input)...
259		throws Exception
260		{
261		// NB: stackoverflow
262		// https://stackoverflow.com/questions/4818468/how-to-check-if-inputstream-is-gzipped
263		// could use a PushBackInputStream rather than a BufferedInputStream
264	0	if (!input.markSupported())
265		{
266	0	input = new BufferedInputStream(input, 16);
267		}
268	0	if (isGzipStream(input))
269		{
270	0	return getGzipReader(input);
271		}
272		// return a buffered reader for the stream.
273	0	InputStreamReader isReader = new InputStreamReader(input);
274	0	BufferedReader toReadFrom = new BufferedReader(isReader);
275	0	return toReadFrom;
276		}
277
278		/**
279		* Returns a {@code BufferedReader} which wraps the input stream with a
280		* GZIPInputStream. Throws a {@code ZipException} if a GZIP format error
281		* occurs or the compression method used is unsupported.
282		*
283		* @param inputStream
284		* @return
285		* @throws Exception
286		*/
		0% Uncovered Elements: 5 (5) Complexity: 1 Complexity Density: 0.2
287	0	private BufferedReader getGzipReader(InputStream inputStream)...
288		throws Exception
289		{
290	0	BufferedReader inData = new BufferedReader(
291		new InputStreamReader(new GZIPInputStream(inputStream)));
292	0	inData.mark(2048);
293	0	inData.read();
294	0	inData.reset();
295	0	return inData;
296		}
297
298		/**
299		* Tries to read from the given URL. If successful, saves a reader to the
300		* response in field {@code dataIn}, otherwise (on exception, or HTTP response
301		* status not 200), throws an exception.
302		* <p>
303		* If the response status includes
304		*
305		* <pre>
306		* Content-Type : application/x-gzip
307		* </pre>
308		*
309		* then tries to read as gzipped content.
310		*
311		* @param urlStr
312		* @throws IOException
313		* @throws MalformedURLException
314		*/
		0% Uncovered Elements: 35 (35) Complexity: 7 Complexity Density: 0.24
315	0	private void checkURLSource(String urlStr)...
316		throws IOException, MalformedURLException
317		{
318	0	errormessage = "URL NOT FOUND";
319	0	URL url = new URL(urlStr);
320	0	URLConnection _conn = HttpUtils.openConnection(url);
321	0	if (_conn instanceof HttpURLConnection)
322		{
323	0	HttpURLConnection conn = HttpUtils
324		.followConnection((HttpURLConnection) _conn);
325	0	int rc = conn.getResponseCode();
326	0	if (rc != HttpURLConnection.HTTP_OK)
327		{
328	0	throw new FileNotFoundException("Response status from " + urlStr
329		+ " was " + conn.getResponseCode());
330		}
331	0	_conn = conn;
332		}
333		else
334		{
335	0	try
336		{
337	0	dataIn = checkForGzipStream(_conn.getInputStream());
338	0	dataName = urlStr;
339		} catch (IOException ex)
340		{
341	0	throw new IOException("Failed to handle non-HTTP URI stream", ex);
342		} catch (Exception ex)
343		{
344	0	throw new IOException(
345		"Failed to determine type of input stream for given URI",
346		ex);
347		}
348	0	return;
349		}
350	0	String encoding = _conn.getContentEncoding();
351	0	String contentType = _conn.getContentType();
352	0	boolean isgzipped = "application/x-gzip".equalsIgnoreCase(contentType)
353		|| contentType.endsWith("gzip") || "gzip".equals(encoding);
354	0	Exception e = null;
355	0	InputStream inputStream = _conn.getInputStream();
356	0	if (isgzipped)
357		{
358	0	try
359		{
360	0	dataIn = getGzipReader(inputStream);
361	0	dataName = urlStr;
362		} catch (Exception e1)
363		{
364	0	throw new IOException(MessageManager
365		.getString("exception.failed_to_resolve_gzip_stream"), e);
366		}
367	0	return;
368		}
369
370	0	dataIn = new BufferedReader(new InputStreamReader(inputStream));
371	0	dataName = urlStr;
372	0	return;
373		}
374
375		/**
376		* sets the suffix string (if any) and returns remainder (if suffix was
377		* detected)
378		*
379		* @param fileStr
380		* @return truncated fileStr or null
381		*/
		0% Uncovered Elements: 7 (7) Complexity: 3 Complexity Density: 0.6
382	0	private String extractSuffix(String fileStr)...
383		{
384		// first check that there wasn't a suffix string tagged on.
385	0	int sfpos = fileStr.lastIndexOf(suffixSeparator);
386	0	if (sfpos > -1 && sfpos < fileStr.length() - 1)
387		{
388	0	suffix = fileStr.substring(sfpos + 1);
389		// jalview.bin.Console.errPrintln("DEBUG: Found Suffix:"+suffix);
390	0	return fileStr.substring(0, sfpos);
391		}
392	0	return null;
393		}
394
395		/**
396		* not for general use, creates a fileParse object for an existing reader with
397		* configurable values for the origin and the type of the source
398		*/
		0% Uncovered Elements: 10 (10) Complexity: 3 Complexity Density: 0.38
399	0	public FileParse(BufferedReader source, String originString,...
400		DataSourceType sourceType)
401		{
402	0	dataSourceType = sourceType;
403	0	error = false;
404	0	inFile = null;
405	0	dataName = originString;
406	0	dataIn = source;
407	0	try
408		{
409	0	if (dataIn.markSupported())
410		{
411	0	dataIn.mark(READAHEAD_LIMIT);
412		}
413		} catch (IOException q)
414		{
415
416		}
417		}
418
419		/**
420		* Create a datasource for input to Jalview. See AppletFormatAdapter for the
421		* types of sources that are handled.
422		*
423		* @param file
424		* - datasource locator/content as File or String
425		* @param sourceType
426		* - protocol of source
427		* @throws MalformedURLException
428		* @throws IOException
429		*/
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
430	0	public FileParse(Object file, DataSourceType sourceType)...
431		throws MalformedURLException, FileNotFoundException, IOException
432		{
433	0	if (file instanceof File)
434		{
435	0	parse((File) file, ((File) file).getPath(), sourceType, true);
436		}
437		else
438		{
439	0	parse(null, file.toString(), sourceType, false);
440		}
441		}
442
		0% Uncovered Elements: 100 (100) Complexity: 28 Complexity Density: 0.45
443	0	private void parse(File file, String fileStr, DataSourceType sourceType,...
444		boolean isFileObject) throws FileNotFoundException, IOException
445		{
446	0	bytes = Platform.getFileBytes(file);
447	0	dataSourceType = sourceType;
448	0	error = false;
449	0	boolean filenotfound = false;
450
451	0	if (sourceType == DataSourceType.FILE)
452		{
453
454	0	if (bytes != null)
455		{
456		// this will be from JavaScript
457	0	inFile = file;
458	0	dataIn = new BufferedReader(
459		new InputStreamReader(new ByteArrayInputStream(bytes)));
460	0	dataName = fileStr;
461		}
462	0	else if (checkFileSource(fileStr))
463		{
464	0	String suffixLess = extractSuffix(fileStr);
465	0	if (suffixLess != null)
466		{
467	0	if (checkFileSource(suffixLess))
468		{
469	0	throw new IOException(MessageManager.formatMessage(
470		"exception.problem_opening_file_also_tried",
471		new String[]
472		{ inFile.getName(), suffixLess, errormessage }));
473		}
474		}
475		else
476		{
477	0	throw new IOException(MessageManager.formatMessage(
478		"exception.problem_opening_file", new String[]
479		{ inFile.getName(), errormessage }));
480		}
481		}
482		}
483	0	else if (sourceType == DataSourceType.RELATIVE_URL)
484		{
485		// BH 2018 hack for no support for access-origin
486	0	bytes = Platform.getFileAsBytes(fileStr);
487	0	dataIn = new BufferedReader(
488		new InputStreamReader(new ByteArrayInputStream(bytes)));
489	0	dataName = fileStr;
490
491		}
492	0	else if (sourceType == DataSourceType.URL)
493		{
494	0	try
495		{
496	0	try
497		{
498	0	checkURLSource(fileStr);
499	0	if (suffixSeparator == '#')
500		{
501	0	extractSuffix(fileStr); // URL lref is stored for later reference.
502		}
503		} catch (IOException e)
504		{
505	0	String suffixLess = extractSuffix(fileStr);
506	0	if (suffixLess == null)
507		{
508	0	if (e instanceof FileNotFoundException
509		|| e instanceof UnknownHostException
510		|| e instanceof SocketTimeoutException)
511		{
512	0	errormessage = "File at URL '" + fileStr + "' not found";
513	0	filenotfound = true;
514		}
515	0	throw (e);
516		}
517		else
518		{
519	0	try
520		{
521	0	checkURLSource(suffixLess);
522		} catch (IOException e2)
523		{
524	0	errormessage = "BAD URL WITH OR WITHOUT SUFFIX '" + fileStr
525		+ "'";
526	0	if (e instanceof FileNotFoundException
527		|| e instanceof UnknownHostException
528		|| e instanceof SocketTimeoutException)
529		{
530	0	filenotfound = true;
531		}
532	0	throw (e); // just pass back original - everything was wrong.
533		}
534		}
535		}
536		} catch (Exception e)
537		{
538	0	errormessage = "CANNOT ACCESS DATA AT URL '" + fileStr + "' ("
539		+ e.getMessage() + ")";
540	0	error = true;
541		}
542		}
543	0	else if (sourceType == DataSourceType.PASTE)
544		{
545	0	errormessage = "PASTE INACCESSIBLE!";
546	0	dataIn = new BufferedReader(new StringReader(fileStr));
547	0	dataName = "Paste";
548		}
549	0	else if (sourceType == DataSourceType.CLASSLOADER)
550		{
551	0	errormessage = "RESOURCE CANNOT BE LOCATED";
552	0	InputStream is = getClass().getResourceAsStream("/" + fileStr);
553	0	if (is == null)
554		{
555	0	String suffixLess = extractSuffix(fileStr);
556	0	if (suffixLess != null)
557		{
558	0	is = getClass().getResourceAsStream("/" + suffixLess);
559		}
560		}
561	0	if (is != null)
562		{
563	0	dataIn = new BufferedReader(new InputStreamReader(is));
564	0	dataName = fileStr;
565		}
566		else
567		{
568	0	error = true;
569		}
570		}
571		else
572		{
573	0	errormessage = "PROBABLE IMPLEMENTATION ERROR : Datasource Type given as '"
574	0	+ (sourceType != null ? sourceType : "null") + "'";
575	0	error = true;
576		}
577	0	if (dataIn == null || error)
578		{
579		// pass up the reason why we have no source to read from
580	0	if (filenotfound)
581		{
582	0	throw new FileNotFoundException(MessageManager
583		.formatMessage("label.url_not_found", new String[]
584		{ errormessage }));
585		}
586	0	throw new IOException(MessageManager.formatMessage(
587		"exception.failed_to_read_data_from_source", new String[]
588		{ errormessage }));
589		}
590	0	error = false;
591	0	dataIn.mark(READAHEAD_LIMIT);
592		}
593
594		/**
595		* mark the current position in the source as start for the purposes of it
596		* being analysed by IdentifyFile().identify
597		*
598		* @throws IOException
599		*/
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
600	0	public void mark() throws IOException...
601		{
602	0	if (dataIn != null)
603		{
604	0	dataIn.mark(READAHEAD_LIMIT);
605		}
606		else
607		{
608	0	throw new IOException(
609		MessageManager.getString("exception.no_init_source_stream"));
610		}
611		}
612
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
613	0	public String nextLine() throws IOException...
614		{
615	0	if (!error)
616		{
617	0	return dataIn.readLine();
618		}
619	0	throw new IOException(MessageManager
620		.formatMessage("exception.invalid_source_stream", new String[]
621		{ errormessage }));
622		}
623
624		/**
625		*
626		* @return true if this FileParse is configured for Export only
627		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
628	0	public boolean isExporting()...
629		{
630	0	return !error && dataIn == null;
631		}
632
633		/**
634		*
635		* @return true if the data source is valid
636		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
637	0	public boolean isValid()...
638		{
639	0	return !error;
640		}
641
642		/**
643		* closes the datasource and tidies up. source will be left in an error state
644		*/
		0% Uncovered Elements: 5 (5) Complexity: 1 Complexity Density: 0.2
645	0	public void close() throws IOException...
646		{
647	0	errormessage = "EXCEPTION ON CLOSE";
648	0	error = true;
649	0	dataIn.close();
650	0	dataIn = null;
651	0	errormessage = "SOURCE IS CLOSED";
652		}
653
654		/**
655		* Rewinds the datasource to the marked point if possible
656		*
657		* @param bytesRead
658		*
659		*/
		0% Uncovered Elements: 9 (9) Complexity: 4 Complexity Density: 0.8
660	0	public void reset(int bytesRead) throws IOException...
661		{
662	0	if (bytesRead >= READAHEAD_LIMIT)
663		{
664	0	jalview.bin.Console.errPrintln(String.format(
665		"File reset error: read %d bytes but reset limit is %d",
666		bytesRead, READAHEAD_LIMIT));
667		}
668	0	if (dataIn != null && !error)
669		{
670	0	dataIn.reset();
671		}
672		else
673		{
674	0	throw new IOException(MessageManager.getString(
675		"error.implementation_error_reset_called_for_invalid_source"));
676		}
677		}
678
679		/**
680		*
681		* @return true if there is a warning for the user
682		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
683	0	public boolean hasWarningMessage()...
684		{
685	0	return (warningMessage != null && warningMessage.length() > 0);
686		}
687
688		/**
689		*
690		* @return empty string or warning message about file that was just parsed.
691		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
692	0	public String getWarningMessage()...
693		{
694	0	return warningMessage;
695		}
696
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
697	0	public String getInFile()...
698		{
699	0	if (inFile != null)
700		{
701	0	return inFile.getAbsolutePath() + " (" + index + ")";
702		}
703		else
704		{
705	0	return "From Paste + (" + index + ")";
706		}
707		}
708
709		/**
710		* @return the dataName
711		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
712	0	public String getDataName()...
713		{
714	0	return dataName;
715		}
716
717		/**
718		* set the (human readable) name or URI for this datasource
719		*
720		* @param dataname
721		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
722	0	protected void setDataName(String dataname)...
723		{
724	0	dataName = dataname;
725		}
726
727		/**
728		* get the underlying bufferedReader for this data source.
729		*
730		* @return null if no reader available
731		* @throws IOException
732		*/
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
733	0	public Reader getReader()...
734		{
735	0	if (dataIn != null) // Probably don't need to test for readiness &&
736		// dataIn.ready())
737		{
738	0	return dataIn;
739		}
740	0	return null;
741		}
742
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
743	0	public AlignViewportI getViewport()...
744		{
745	0	return viewport;
746		}
747
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
748	0	public void setViewport(AlignViewportI viewport)...
749		{
750	0	this.viewport = viewport;
751		}
752
753		/**
754		* @return the currently configured exportSettings for writing data.
755		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
756	0	public AlignExportSettingsI getExportSettings()...
757		{
758	0	return exportSettings;
759		}
760
761		/**
762		* Set configuration for export of data.
763		*
764		* @param exportSettings
765		* the exportSettings to set
766		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
767	0	public void setExportSettings(AlignExportSettingsI exportSettings)...
768		{
769	0	this.exportSettings = exportSettings;
770		}
771
772		/**
773		* method overridden by complex file exporter/importers which support
774		* exporting visualisation and layout settings for a view
775		*
776		* @param avpanel
777		*/
		0% Uncovered Elements: 4 (4) Complexity: 2 Complexity Density: 1
778	0	public void configureForView(AlignmentViewPanel avpanel)...
779		{
780	0	if (avpanel != null)
781		{
782	0	setViewport(avpanel.getAlignViewport());
783		}
784		// could also set export/import settings
785		}
786
787		/**
788		* Returns the preferred feature colour configuration if there is one, else
789		* null
790		*
791		* @return
792		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
793	0	public FeatureSettingsModelI getFeatureColourScheme()...
794		{
795	0	return null;
796		}
797
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
798	0	public DataSourceType getDataSourceType()...
799		{
800	0	return dataSourceType;
801		}
802
803		/**
804		* Returns a buffered reader for the input object. Returns null, or throws
805		* IOException, on failure.
806		*
807		* @param file
808		* a File, or a String which is a name of a file
809		* @param sourceType
810		* @return
811		* @throws IOException
812		*/
		0% Uncovered Elements: 36 (36) Complexity: 10 Complexity Density: 0.36
813	0	public BufferedReader getBufferedReader(Object file,...
814		DataSourceType sourceType) throws IOException
815		{
816	0	BufferedReader in = null;
817	0	byte[] bytes;
818
819	0	switch (sourceType)
820		{
821	0	case FILE:
822	0	if (file instanceof String)
823		{
824	0	return new BufferedReader(new FileReader((String) file));
825		}
826	0	bytes = Platform.getFileBytes((File) file);
827	0	if (bytes != null)
828		{
829	0	return new BufferedReader(
830		new InputStreamReader(new ByteArrayInputStream(bytes)));
831		}
832	0	return new BufferedReader(new FileReader((File) file));
833	0	case URL:
834	0	URL url = new URL(file.toString());
835	0	in = new BufferedReader(
836		new InputStreamReader(HttpUtils.openStream(url)));
837	0	break;
838	0	case RELATIVE_URL: // JalviewJS only
839	0	bytes = Platform.getFileAsBytes(file.toString());
840	0	if (bytes != null)
841		{
842	0	in = new BufferedReader(
843		new InputStreamReader(new ByteArrayInputStream(bytes)));
844		}
845	0	break;
846	0	case PASTE:
847	0	in = new BufferedReader(new StringReader(file.toString()));
848	0	break;
849	0	case CLASSLOADER:
850	0	InputStream is = getClass().getResourceAsStream("/" + file);
851	0	if (is != null)
852		{
853	0	in = new BufferedReader(new InputStreamReader(is));
854		}
855	0	break;
856		}
857
858	0	return in;
859		}
860		}