Symaptic: os/kernelhwsrv/kernel/eka/debug/crashMonitor/src/scmbytestreamutil.cpp@260cb5ec6c19

     1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\debug\crashMonitor\src\scmbytestreamutil.cpp

    15 // some utility classes for writing data to flash buffer

    16 //

    17 //

    19 /**

    20  @file

    21  @internalTechnology

    22 */

    25 #include "scmbytestreamutil.h"

    26 #include "scmtrace.h"

    30 namespace Debug

    31 	{

    32 	/**

    33 	 * TByteStreamBase Constructor

    34 	 * @param aBuffer - pointer to buffer that this utility will use

    35 	 */

    36 	TByteStreamBase::TByteStreamBase(TUint8* aBuffer)

    37 		: iBuffer(aBuffer)

    38 		, iPos(0)

    39 		{

    40 		}

    42 	/**

    43 	 * SetPosition

    44 	 * @param aBuffer - Sets iPos

    45 	 * @return void

    46 	 */

    47 	void TByteStreamBase::SetPosition(TInt aPos)

    48 		{

    49 		iPos = aPos;

    50 		}

    52 	/**

    53 	 * CurrentPosition

    54 	 * @param aBuffer - Returns the current value of iPos

    55 	 * @return Tint

    56 	 */

    57 	TInt TByteStreamBase::CurrentPosition() const

    58 		{

    59 		return iPos;

    60 		}

    62 	/**

    63 	 * TByteStreamReader Constructor

    64 	 * @param aBuffer - pointer to buffer that this utility will use

    65 	 */

    66 	TByteStreamReader::TByteStreamReader(TUint8* aBuffer)

    67 		: TByteStreamBase(aBuffer)

    68 		{

    69 		}

    72 	/**

    73 	 * Constructor for TByteStreamWriter

    74 	 * @param aBuffer buffer for writing

    75 	 * @param aPhysEnabled whether or not physical writing to another media is enabled

    76 	 */

    77 	TByteStreamWriter::TByteStreamWriter(TUint8* aBuffer, TBool aPhysEnabled)

    78 		: TByteStreamBase(aBuffer)

    79 		, iPhysEnabled(aPhysEnabled)

    80 		, iBytesWritten(0)

    81 		{

    82 		}

    84 	/**

    85 	 * Writes a byte to the buffer

    86 	 * @param aValue Byte to write

    87 	 */

    88 	void TByteStreamWriter::WriteByte(TUint8 aValue)

    89 		{

    90 		if(iBuffer)

    91 			{

    92 			iBuffer[iPos++] = aValue;

    93 			++iBytesWritten;

    94 			}

    95 		}

    97 	/**

    98 	 * Resets the byte counter back to zero

    99 	 */

   100 	void TByteStreamWriter::ResetBytesWritten()

   101 		{

   102 		iBytesWritten = 0;

   103 		}

   105 	/**

   106 	 * TCachedByteStreamWriter Constructor

   107 	 * @param aBuffer - pointer to buffer that this utility will use

   108 	 * @param aCacheSize - suggested length of cache to use if greater than EMaxCache

   109 	 * 					cache length of EMaxCache will be used

   110 	 */

   111 	TCachedByteStreamWriter::TCachedByteStreamWriter(TUint8* aCacheBuffer, TInt aCacheSize, TBool aPhysEnabled)

   112 		: TByteStreamWriter(NULL, aPhysEnabled)

   113 		, iCacheSize(aCacheSize)

   114 		, iCacheBuffer(aCacheBuffer)

   115 		, iPhysicalWriter(NULL)

   116 		{

   117 		}

   120 	/**

   121 	 * FlushCache

   122 	 * Writes the contents of the cache to buffer amd/or to physical writer implementation

   123 	 * if one is currently set

   124 	 * @return void

   125 	 */

   126 	TInt TCachedByteStreamWriter::FlushCache()

   127 		{

   128 		TInt padCount = iCacheSize - iPos;

   129 		if(padCount > 0)

   130 			{

   131 			for(TInt i=0;i<padCount;i++)

   132 				{

   133 				iCacheBuffer[iPos++] = 0;

   134 				}

   135 			}

   137 		if(iPhysEnabled)

   138 			{

   139 			if(iPhysicalWriter) // do we have a writer to send the cache data to

   140 				{

   141 				iPhysicalWriter->DoPhysicalWrite(iCacheBuffer, iBytesWritten, iPos);

   142 				}

   143 			}

   145 		iPos = 0;

   146 		return KErrNone;

   147 		}

   149 	/**

   150 	 * Writes a byte to the cached buffer

   151 	 * @param aValue Byte to write

   152 	 */

   153 	void TCachedByteStreamWriter::WriteByte(TUint8 aValue)

   154 		{

   155 		if(iPos == iCacheSize)

   156 			{

   157 			FlushCache();

   158 			}

   159 		iCacheBuffer[iPos++] = aValue;

   160 		++iBytesWritten;

   161 		}

   163 	/**

   164 	 * CurrentPosition

   165 	 * @param aBuffer -  need to return the position in buffer plus the write pos into cache

   166 	 * @return Tint

   167 	 */

   168 	TInt TCachedByteStreamWriter::CurrentPosition() const

   169 		{

   170 		return iBytesWritten;

   171 		}

   173 	/**

   174 	 * SetWriterImpl

   175 	 * @param aPhysicalWriter - sets the physical writer implementation to be used when the cache is flushed

   176 	 * 							pass NULL to remove a previous writer implementation

   177 	 * @return void

   178 	 */

   179 	void TCachedByteStreamWriter::SetWriterImpl(MPhysicalWriterImpl* aPhysicalWriter)

   180 		{

   181 		iPhysicalWriter = aPhysicalWriter;

   182 		}

   183 	}

   185 //eof

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--