1 /*

     2  * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  * Plain Text Reader

    17  *

    18  */

    19 package com.nokia.traceviewer.engine;

    20 

    21 import java.io.BufferedReader;

    22 import java.io.File;

    23 import java.io.FileReader;

    24 import java.io.IOException;

    25 import java.nio.CharBuffer;

    26 

    27 /**

    28  * Plain Text Reader

    29  */

    30 public class PlainTextReader extends BaseDataReader {

    31 

    32 	/**

    33 	 * Running boolean

    34 	 */

    35 	private boolean running;

    36 

    37 	/**

    38 	 * Position of file

    39 	 */

    40 	private long filePos;

    41 

    42 	/**

    43 	 * File reader

    44 	 */

    45 	private BufferedReader input;

    46 

    47 	/**

    48 	 * File to read from

    49 	 */

    50 	private File file;

    51 

    52 	/**

    53 	 * Character buffer where chars are read

    54 	 */

    55 	private final CharBuffer cbuf;

    56 

    57 	/**

    58 	 * Remaining characters from the last read

    59 	 */

    60 	private int remainingChars;

    61 

    62 	/**

    63 	 * Temporary buffer for data

    64 	 */

    65 	private final CharBuffer tempBuffer;

    66 

    67 	/**

    68 	 * Paused boolean

    69 	 */

    70 	private boolean paused;

    71 

    72 	/**

    73 	 * Indicates that traces can be processed

    74 	 */

    75 	private boolean canProcessTraces;

    76 

    77 	/**

    78 	 * Possible middle of line break

    79 	 */

    80 	private boolean middleOfLineBreak;

    81 

    82 	/**

    83 	 * Constructor

    84 	 * 

    85 	 * @param mediaCallback

    86 	 *            callback

    87 	 * @param configuration

    88 	 *            trace configuration used in this reader

    89 	 */

    90 	public PlainTextReader(MediaCallback mediaCallback,

    91 			TraceConfiguration configuration) {

    92 		super();

    93 		this.mediaCallback = mediaCallback;

    94 		trace = new TraceProperties(configuration);

    95 		traceConfiguration = configuration;

    96 		cbuf = CharBuffer.allocate(RECEIVE_BUFFER_SIZE);

    97 		tempBuffer = CharBuffer.allocate(MAX_MESSAGE_SIZE);

    98 

    99 		running = true;

   100 	}

   101 

   102 	/*

   103 	 * (non-Javadoc)

   104 	 * 

   105 	 * @see com.nokia.traceviewer.engine.DataReader#start()

   106 	 */

   107 	@Override

   108 	public void run() {

   109 		try {

   110 			file = new File(filePath);

   111 			input = new BufferedReader(new FileReader(file));

   112 			while (running) {

   113 				canProcessTraces = true;

   114 				if (!paused) {

   115 					// Read from the file

   116 					int chars = input.read(cbuf);

   117 					if (chars > 0) {

   118 						cbuf.limit(chars + remainingChars);

   119 						remainingChars = 0;

   120 						processBuffer();

   121 					} else {

   122 						// Inform callback for EOF

   123 						mediaCallback.endOfFile(this);

   124 						Thread.sleep(PAUSE_TIME);

   125 					}

   126 				} else {

   127 					Thread.sleep(PAUSE_TIME);

   128 				}

   129 			}

   130 

   131 		} catch (Throwable t) {

   132 			t.printStackTrace();

   133 		}

   134 

   135 	}

   136 

   137 	/**

   138 	 * Process character buffer

   139 	 */

   140 	private void processBuffer() {

   141 		canProcessTraces = true;

   142 		cbuf.position(0);

   143 		StringBuffer buf = new StringBuffer();

   144 		int extra = 0;

   145 		boolean traceReady = false;

   146 

   147 		// Loop until there is characters left

   148 		while (cbuf.hasRemaining()) {

   149 			char c = cbuf.get();

   150 

   151 			// If in the middle of a line break from previous buffer, skip first

   152 			// character

   153 			if (middleOfLineBreak && c == '\n' && cbuf.hasRemaining()) {

   154 				c = cbuf.get();

   155 			}

   156 			middleOfLineBreak = false;

   157 

   158 			// Check the character

   159 			switch (c) {

   160 			case '\n':

   161 				extra = 1;

   162 				traceReady = true;

   163 				break;

   164 			case '\r':

   165 				if (!cbuf.hasRemaining()) {

   166 					extra = 1;

   167 					middleOfLineBreak = true;

   168 				} else if ((cbuf.get()) == '\n') {

   169 					extra = 2;

   170 				} else {

   171 					cbuf.position(cbuf.position() - 1);

   172 					extra = 1;

   173 				}

   174 

   175 				traceReady = true;

   176 				break;

   177 			default:

   178 				buf.append(c);

   179 				traceReady = false;

   180 			}

   181 

   182 			// Trace is ready, insert it

   183 			if (traceReady) {

   184 				String traceString = buf.toString();

   185 				buf.setLength(0);

   186 				if (canProcessTraces) {

   187 					processTrace(extra, traceString);

   188 				}

   189 				extra = 0;

   190 				traceReady = false;

   191 			}

   192 		}

   193 		remainingChars = buf.length();

   194 

   195 		// If the end of the file and there is characters in the buffer, process

   196 		// the remaining trace

   197 		if ((filePos + remainingChars) >= file.length()

   198 				&& buf.length() > 0

   199 				&& !TraceViewerGlobals.getTraceViewer()

   200 						.getDataProcessorAccess().getFilterProcessor()

   201 						.isProcessingFilter()) {

   202 			String traceString = buf.toString();

   203 			if (canProcessTraces) {

   204 				processTrace(extra, traceString);

   205 			}

   206 			remainingChars = 0;

   207 		}

   208 

   209 		// Copy the remaining characters to the start of the buffer

   210 		copyRemainingToBufferStart();

   211 	}

   212 

   213 	/**

   214 	 * Copy remaining characters to the start of the buffer

   215 	 */

   216 	private void copyRemainingToBufferStart() {

   217 		if (remainingChars > 0 && canProcessTraces) {

   218 			cbuf.position(cbuf.limit() - remainingChars);

   219 			cbuf.limit(cbuf.limit());

   220 			tempBuffer.position(0);

   221 			tempBuffer.limit(MAX_MESSAGE_SIZE);

   222 			tempBuffer.put(cbuf);

   223 

   224 			cbuf.position(0);

   225 			cbuf.limit(RECEIVE_BUFFER_SIZE);

   226 			tempBuffer.position(0);

   227 			tempBuffer.limit(remainingChars);

   228 

   229 			cbuf.put(tempBuffer);

   230 			cbuf.position(remainingChars);

   231 		} else {

   232 			remainingChars = 0;

   233 			cbuf.position(0);

   234 			cbuf.limit(RECEIVE_BUFFER_SIZE);

   235 		}

   236 	}

   237 

   238 	/**

   239 	 * Process trace

   240 	 * 

   241 	 * @param extra

   242 	 *            number of extra linefeed characters to add to file position

   243 	 * @param traceString

   244 	 *            trace string

   245 	 */

   246 	private void processTrace(int extra, String traceString) {

   247 		traceCount++;

   248 		trace = new TraceProperties(traceConfiguration);

   249 		trace.traceString = traceString;

   250 		trace.traceNumber = traceCount;

   251 

   252 		// Count the file position if trace is dividable by

   253 		// blockSize

   254 		if (traceCount % TraceViewerGlobals.blockSize == 1) {

   255 			fileMap.insert(Long.valueOf(filePos));

   256 		}

   257 		filePos += trace.traceString.length() + extra;

   258 

   259 		// Check if last trace

   260 		checkLastTrace();

   261 

   262 		mediaCallback.processTrace(trace);

   263 

   264 	}

   265 

   266 	/**

   267 	 * Checks if last trace

   268 	 */

   269 	private void checkLastTrace() {

   270 		if (filePos >= file.length()) {

   271 			trace.lastTrace = true;

   272 		} else {

   273 			trace.lastTrace = false;

   274 		}

   275 	}

   276 

   277 	/*

   278 	 * (non-Javadoc)

   279 	 * 

   280 	 * @see com.nokia.traceviewer.engine.DataReader#pause(boolean)

   281 	 */

   282 	public void pause(boolean pause) {

   283 		paused = pause;

   284 	}

   285 

   286 	/*

   287 	 * (non-Javadoc)

   288 	 * 

   289 	 * @see com.nokia.traceviewer.engine.DataReader#shutdown()

   290 	 */

   291 	public void shutdown() {

   292 		running = false;

   293 		// Close the stream

   294 		try {

   295 			if (input != null) {

   296 				input.close();

   297 			}

   298 		} catch (IOException e) {

   299 			e.printStackTrace();

   300 		}

   301 	}

   302 

   303 	/*

   304 	 * (non-Javadoc)

   305 	 * 

   306 	 * @see com.nokia.traceviewer.engine.DataReader#setFilePosition(long)

   307 	 */

   308 	@Override

   309 	public void setFilePosition(long filePos) {

   310 		// Start from the beginning

   311 		if (filePos == 0) {

   312 			try {

   313 				canProcessTraces = false;

   314 				input.close();

   315 				this.filePos = 0;

   316 				remainingChars = 0;

   317 				fileMap.clearMap();

   318 				traceCount = 0;

   319 				cbuf.clear();

   320 				file = new File(filePath);

   321 				input = new BufferedReader(new FileReader(file));

   322 				paused = false;

   323 			} catch (Exception e) {

   324 				e.printStackTrace();

   325 			}

   326 		}

   327 	}

   328 

   329 	/*

   330 	 * (non-Javadoc)

   331 	 * 

   332 	 * @see com.nokia.traceviewer.engine.DataReader#clearFile()

   333 	 */

   334 	@Override

   335 	public void clearFile() {

   336 		super.clearFile();

   337 		setFilePosition(0);

   338 	}

   339 

   340 	/*

   341 	 * (non-Javadoc)

   342 	 * 

   343 	 * @see

   344 	 * com.nokia.traceviewer.engine.BaseDataReader#createScrollReader(com.nokia

   345 	 * .traceviewer.engine.MediaCallback,

   346 	 * com.nokia.traceviewer.engine.TraceConfiguration)

   347 	 */

   348 	@Override

   349 	public DataScrollReader createScrollReader(MediaCallback mediaCallback,

   350 			TraceConfiguration conf) {

   351 		return new PlainTextScrollReader(mediaCallback, conf);

   352 	}

   353 

   354 	/*

   355 	 * (non-Javadoc)

   356 	 * 

   357 	 * @see com.nokia.traceviewer.engine.DataReader#isPaused()

   358 	 */

   359 	public boolean isPaused() {

   360 		return paused;

   361 	}

   362 

   363 	/*

   364 	 * (non-Javadoc)

   365 	 * 

   366 	 * @see com.nokia.traceviewer.engine.DataReader#getTracePositionInFile()

   367 	 */

   368 	public long getTracePositionInFile() {

   369 		return filePos;

   370 	}

   371 

   372 	@Override

   373 	protected byte[] setProtocolSpecificStuffToMultiPartTrace(byte[] byteArr,

   374 			TraceProperties trace) {

   375 		// There isn't any multipart traces in plain text

   376 		return byteArr;

   377 	}

   378 }