FCL/sftools/ana/dynaanamdw/crashmdw: comparison crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianUtils/BasicTypes/SymUInt.cs

equal deleted inserted replaced

--1:000000000000
+:818e61de6cd1
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+using System;
+using System.Collections.Generic;
+using System.Text;
+namespace SymbianUtils.BasicTypes
+{
+public class SymUInt32 : SymUIntBase
+{
+#region Constructors
+public SymUInt32( uint aValue )
+: base( aValue, 32 )
+{
+}
+public SymUInt32( string aBinary )
+: base( aBinary, 32 )
+{
+}
+#endregion
+#region Operators
+public static SymUInt32 operator &( SymUInt32 aLeft, SymUInt32 aRight )
+{
+uint val = aLeft.RawValue & aRight.RawValue;
+return new SymUInt32( val );
+}
+public static implicit operator SymUInt32( uint aBasicType )
+{
+return new SymUInt32( aBasicType );
+}
+#endregion
+}
+public class SymUInt16 : SymUIntBase
+{
+#region Constructors
+public SymUInt16( ushort aValue )
+: base( aValue, 16 )
+{
+}
+public SymUInt16( string aBinary )
+: base( aBinary, 16 )
+{
+}
+#endregion
+#region Operators
+public static SymUInt16 operator &( SymUInt16 aLeft, SymUInt16 aRight )
+{
+ushort val = Convert.ToUInt16( aLeft.RawValue & aRight.RawValue );
+return new SymUInt16( val );
+}
+public static implicit operator SymUInt16( ushort aBasicType )
+{
+return new SymUInt16( aBasicType );
+}
+#endregion
+}
+public class SymUInt8 : SymUIntBase
+{
+#region Constructors
+public SymUInt8( byte aValue )
+: base( aValue, 8 )
+{
+}
+public SymUInt8( string aBinary )
+: base( aBinary, 8 )
+{
+}
+#endregion
+#region Operators
+public static SymUInt8 operator &( SymUInt8 aLeft, SymUInt8 aRight )
+{
+byte val = Convert.ToByte( aLeft.RawValue & aRight.RawValue );
+return new SymUInt8( val );
+}
+public static implicit operator SymUInt8( byte aBasicType )
+{
+return new SymUInt8( aBasicType );
+}
+#endregion
+}
+public abstract class SymUIntBase : IFormattable
+{
+#region Constructors
+protected SymUIntBase()
+{
+}
+protected SymUIntBase( string aBinary, int aNumberOfBits )
+{
+iValue = SymBitUtils.CreateMask( aBinary );
+iNumberOfBits = aNumberOfBits;
+}
+protected SymUIntBase( uint aValue, int aNumberOfBits )
+{
+iValue = aValue;
+iNumberOfBits = aNumberOfBits;
+}
+#endregion
+#region API
+public bool IsMatch( string aBinary )
+{
+uint value = 0;
+uint mask = SymBitUtils.CreateMask( aBinary, out value );
+bool ret = ( mask & iValue ) == value;
+return ret;
+}
+public uint RShift( int aBits )
+{
+uint v = iValue;
+v >>= aBits;
+this.RawValue = v;
+return v;
+}
+public uint LShift( int aBits )
+{
+uint v = (uint) ( iValue << aBits );
+this.RawValue = v;
+return v;
+}
+public SymUInt32 RotateRight( int aCount )
+{
+uint ret = iValue;
+//
+for ( int i = 0; i < aCount; i++ )
+{
+bool bitZeroSet = ( ( ret & 0x1 ) == 0x1 );
+ret >>= 1;
+//
+if ( bitZeroSet )
+{
+// Wrap the bit around by appling it at the top end
+ret |= KTopBit;
+}
+}
+//
+return new SymUInt32( ret );
+}
+public uint ToUInt()
+{
+return iValue;
+}
+#endregion
+#region Properties
+public int NumberOfBits
+{
+get { return iNumberOfBits; }
+protected set
+{
+switch ( value )
+{
+default:
+throw new ArgumentException( "Number of bits must be 8, 16 or 32" );
+case 8:
+case 16:
+case 32:
+iNumberOfBits = value;
+break;
+}
+}
+}
+public int NumberOfBytes
+{
+get { return NumberOfBits / 4; }
+set
+{
+this.NumberOfBits = value * 8;
+}
+}
+public uint MaxValue
+{
+get
+{
+uint ret = uint.MaxValue;
+if ( iNumberOfBits == 16 )
+{
+ret = ushort.MaxValue;
+}
+else if ( iNumberOfBits == 8 )
+{
+ret = byte.MaxValue;
+}
+return ret;
+}
+}
+public string Binary
+{
+get
+{
+string bits = SymBitUtils.BeautifyBits( iValue, iNumberOfBits );
+return bits;
+}
+}
+public string Hex
+{
+get
+{
+string hex = iValue.ToString( string.Format( "x{0}", this.NumberOfBytes * 2 ) );
+return hex;
+}
+}
+public SymBit this[ int aIndex ]
+{
+get
+{
+if ( aIndex < 0 || aIndex > iNumberOfBits )
+{
+throw new ArgumentException( "Specified bit is out of bounds" );
+}
+uint mask = ( 1u << aIndex );
+SymBit ret = ( ( mask & iValue ) == mask ) ? SymBit.ESet : SymBit.EClear;
+return ret;
+}
+}
+public SymUInt32 this[ int aHighBitIndex, int aLowBitIndex ]
+{
+get
+{
+if ( aHighBitIndex < aLowBitIndex )
+{
+throw new ArgumentException( "High bit index must be less than low bit index" );
+}
+// Build mask
+uint mask = 0;
+for ( int i = aLowBitIndex; i <= aHighBitIndex; i++ )
+{
+mask |= ( 1u << i );
+}
+uint ret = iValue & mask;
+// Shift
+ret >>= aLowBitIndex;
+return new SymUInt32( ret );
+}
+}
+#endregion
+#region Operators
+public static implicit operator uint( SymUIntBase aObject )
+{
+return aObject.RawValue;
+}
+public static implicit operator ushort( SymUIntBase aObject )
+{
+ushort ret = Convert.ToUInt16( aObject.RawValue );
+return ret;
+}
+public static implicit operator byte( SymUIntBase aObject )
+{
+byte ret = Convert.ToByte( aObject.RawValue );
+return ret;
+}
+public static bool operator ==( SymUIntBase aLeft, SymUIntBase aRight )
+{
+// If both are null, or both are same instance, return true.
+if ( System.Object.ReferenceEquals( aLeft, aRight ) )
+{
+return true;
+}
+// If one is null, but not both, return false.
+if ( ( (object) aLeft == null ) || ( (object) aRight == null ) )
+{
+return false;
+}
+bool ret = aLeft.Equals( aRight );
+return ret;
+}
+public static bool operator !=( SymUIntBase aLeft, SymUIntBase aRight )
+{
+bool result = !( aLeft == aRight );
+return result;
+}
+public static SymUInt32 operator &( SymUIntBase aLeft, SymUIntBase aRight )
+{
+uint val = ( aLeft.RawValue & aRight.RawValue );
+return new SymUInt32( val );
+}
+#endregion
+#region IFormattable Members
+public string ToString( string aFormat, IFormatProvider aFormatProvider )
+{
+if ( aFormatProvider != null )
+{
+ICustomFormatter formatter = aFormatProvider.GetFormat( this.GetType() ) as ICustomFormatter;
+if ( formatter != null )
+{
+return formatter.Format( aFormat, this, aFormatProvider );
+}
+}
+string ret = string.Empty;
+string format = aFormat != null ? aFormat : "full";
+//
+switch ( format )
+{
+case "full":
+ret = string.Format( "0x{0} [{1}]", Hex, Binary );
+break;
+default:
+ret = iValue.ToString( aFormat, aFormatProvider );
+break;
+}
+//
+return ret;
+}
+#endregion
+#region From System.Object
+public override string ToString()
+{
+return ToString( null );
+}
+public string ToString( string aFormat )
+{
+return ToString( aFormat, null );
+}
+public override bool Equals( object aObject )
+{
+bool ret = false;
+//
+if ( aObject != null && aObject is SymUIntBase )
+{
+SymUIntBase other = (SymUIntBase) aObject;
+//
+if ( other.NumberOfBits == this.NumberOfBits )
+{
+ret = ( other.RawValue == this.RawValue );
+}
+}
+//
+return ret;
+}
+public override int GetHashCode()
+{
+return iValue.GetHashCode();
+}
+#endregion
+#region Internal properties & methods
+protected uint RawValue
+{
+get { return iValue; }
+set
+{
+if ( value > MaxValue )
+{
+throw new ArgumentException( string.Format( "Specified value {0} exceeds bit range ({1})", value, this.NumberOfBits ) );
+}
+iValue = value;
+}
+}
+#endregion
+#region Internal constants
+private const uint KTopBit = 0x80000000;
+#endregion
+#region Data ember
+private uint iValue = 0;
+private int iNumberOfBits = 32;
+#endregion
+}
+}