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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

//

#include "sl_std.h"

//-----------------------------------------------------------------------------

/**

    Removes trailing dots from aName.

    @return new string descriptor that may have its length adjusted

*/

TPtrC RemoveTrailingDots(const TDesC& aName)

{

    TInt len = aName.Length();

    while(len > 0)

    {

        if(aName[len-1] == '.')

            len--;

        else

            break;

    }

    TPtrC ptrNoDots(aName.Ptr(), len);

    return ptrNoDots;

}

TUint32 Log2(TUint32 aVal)

{

    __ASSERT_COMPILE(sizeof(TUint32) == 4);

    ASSERT(aVal);

    TUint32 bitPos=31;

    if(!(aVal >> 16)) {bitPos-=16; aVal<<=16;}

    if(!(aVal >> 24)) {bitPos-=8;  aVal<<=8 ;}

    if(!(aVal >> 28)) {bitPos-=4;  aVal<<=4 ;}

    if(!(aVal >> 30)) {bitPos-=2;  aVal<<=2 ;}

    if(!(aVal >> 31)) {bitPos-=1;}

    return bitPos;

}

TTime DosTimeToTTime(TInt aDosTime,TInt aDosDate)

//

//	Deciphers the dos time/date entry information and converts to TTime

//

	{

	TInt secMask=0x1F;

	TInt minMask=0x07E0;

	TInt hrMask=0xF800;

	TInt dayMask=0x1F;

	TInt monthMask=0x01E0;

	TInt yearMask=0xFE00;

	TInt secs=(aDosTime&secMask)*2;

	TInt mins=(aDosTime&minMask)>>5;

	TInt hrs=(aDosTime&hrMask)>>11;

	TInt days=(aDosDate&dayMask)-1;

	TMonth months=(TMonth)(((aDosDate&monthMask)>>5)-1);

	TInt years=((aDosDate&yearMask)>>9)+1980;

	TDateTime datetime;

	TInt ret=datetime.Set(years,months,days,hrs,mins,secs,0);

	if (ret==KErrNone)

		return(TTime(datetime));

	return(TTime(0));

	}

TInt DosTimeFromTTime(const TTime& aTime)

//

// Converts a TTime to a dos time

//

	{

	TDateTime dateTime=aTime.DateTime();

	TInt dosSecs=dateTime.Second()/2;

	TInt dosMins=dateTime.Minute()<<5;

	TInt dosHrs=dateTime.Hour()<<11;

	return dosSecs|dosMins|dosHrs;

	}

TInt DosDateFromTTime(const TTime& aTime)

//

// Converts a TTime to a dos date

//

	{

	TDateTime dateTime=aTime.DateTime();

	TInt dosDays=dateTime.Day()+1;

	TInt dosMonths=(dateTime.Month()+1)<<5;

	TInt dosYears=(dateTime.Year()-1980)<<9;

	return dosDays|dosMonths|dosYears;

	}

TBuf8<12> DosNameToStdFormat(const TDesC8& aDosName)

//

// Converts xxx.yyy to standard format aaaaaaaayyy

//

	{

	__ASSERT_DEBUG(aDosName.Length()>=0 && aDosName.Length()<=12,Fault(EFatBadDosFormatName));

	TBuf8<12> result;

	Mem::Fill((TUint8*)result.Ptr(),result.MaxSize(),' ');

	TInt dotPos=aDosName.Locate('.');

	if (dotPos==KErrNotFound)

		{

		result=aDosName;

		result.SetLength(11);

		return result;

		}

	result=aDosName.Left(dotPos);

	result.SetLength(11);

	TPtr8 ext(&result[8],3);

	ext=aDosName.Right(aDosName.Length()-dotPos-1);

	return result;

	}

TBuf8<12> DosNameFromStdFormat(const TDesC8& aStdFormatName)

//

// Converts aaaaaaaayyy to dos name format xxx.yyy

//

	{

	__ASSERT_DEBUG(aStdFormatName.Length()==11,Fault(EFatBadStdFormatName));

	TBuf8<12> result;

	TInt nameLen=aStdFormatName.Locate(' ');

	if (nameLen>8 || nameLen==KErrNotFound)

		nameLen=8;

	result=aStdFormatName.Left(nameLen);

	TPtrC8 ext(&aStdFormatName[8],3);

	TInt extLen=ext.Locate(' ');

	if (extLen)

		result.Append(TChar('.'));

	if (extLen==KErrNotFound)

		extLen=3;

	result.Append(ext.Left(extLen));

    if(result.Length() && result[0]==0x05 )

	    {

	    result[0]=0xE5;

	    }

	return result;

	}

TInt NumberOfVFatEntries(TInt aNameLength)

//

// Return the number of VFat entries required to describe a filename of length aNameLength

//

	{

	TInt numberOfEntries=0;

	if (aNameLength%KMaxVFatEntryName)

		aNameLength++;	//	Include a zero terminator

//	If aNameLength is a exact multiple of KMaxVFatEntryName, don't bother

//	with a zero terminator - it just adds an unnecessary directory entry		

	numberOfEntries=(1+(aNameLength/KMaxVFatEntryName));	

	if (aNameLength%KMaxVFatEntryName)

		numberOfEntries++;

	return(numberOfEntries);

	}

//-----------------------------------------------------------------------------

/** 

    Calculate DOS short name checksum

    @param aShortName short name descriptor (must be at least 11 bytes long)

    @return checksum

*/

TUint8 CalculateShortNameCheckSum(const TDesC8& aShortName)

    {

    ASSERT(aShortName.Length() >= KFatDirNameSize);

    const TUint8* pName = aShortName.Ptr();

    const TUint32 w0 = ((const TUint32*)pName)[0];

    const TUint32 w1 = ((const TUint32*)pName)[1];

    TUint32 chkSum = w0 & 0xFF;

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + ((w0 << 16) >> 24));

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + ((w0 << 8)  >> 24));

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + ( w0 >> 24));

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + (w1) & 0xFF);

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + ((w1 << 16) >> 24));

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + ((w1 << 8)  >> 24));

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + ( w1 >> 24));

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + pName[8]);

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + pName[9]);

    chkSum = (TUint8)(((chkSum<<7) | (chkSum>>1)) + pName[10]);

    return (TUint8)chkSum;

    }

//-----------------------------------------------------------------------------

const TUint32 K_FFFF = 0xFFFFFFFF; //-- all one bits, beware rigth shifts of signed integers!

RBitVector::RBitVector()

          :iNumBits(0), ipData(NULL), iNumWords(0)

    {

    }

RBitVector::~RBitVector()

    {

    Close();

    }

/**

    Panics.

    @param aPanicCode   a panic code

*/

void RBitVector::Panic(TPanicCode aPanicCode) const

    {

    _LIT(KPanicCat,"RBitVector");

    User::Panic(KPanicCat, aPanicCode);

    }

/** explicitly closes the object and deallocates memory */

void RBitVector::Close()

    {

    iNumBits = 0;

    iNumWords =0;

    User::Free(ipData);

    ipData = NULL;

    }

//-----------------------------------------------------------------------------

/**

    Comparison perator.

    @param  aRhs a vector to compate with.

    @panic ESizeMismatch in the case of different vector sizes

*/

TBool RBitVector::operator==(const RBitVector& aRhs) const

    {

    __ASSERT_ALWAYS(ipData, Panic(ENotInitialised));

    __ASSERT_ALWAYS(iNumBits == aRhs.iNumBits, Panic(ESizeMismatch));

    if(!iNumBits)

        return ETrue; //-- comparing 0-lenght arrays

    if(this == &aRhs)

        return ETrue; //-- comparing with itself

    if(iNumWords >= 1)

        {

        const TUint32 cntBytes = (iNumBits >> 5) << 2; //-- bytes to compare

        if(memcompare((const TUint8*)ipData, cntBytes, (const TUint8*)aRhs.ipData, cntBytes))

            return EFalse;

        }

    const TUint32 bitsRest  = iNumBits & 0x1F;

    if(bitsRest)

        {

        const TUint32 mask = K_FFFF >> (32-bitsRest);

        return ( (ipData[iNumWords-1] & mask) == (aRhs.ipData[iNumWords-1] & mask) );

        }

    return ETrue;

    }

TBool RBitVector::operator!=(const RBitVector& aRhs) const  

    {

    return ! ((*this) == aRhs);

    } 

//-----------------------------------------------------------------------------

/** The same as Create(), but leaves on error */

void RBitVector::CreateL(TUint32 aNumBits)

    {

    User::LeaveIfError(Create(aNumBits));

    }

/**

    Create the vector with the size of aNumBits bits.

    @return system-wide error codes:

        KErrNoMemory    unable to allocate sufficient amount of memory for the array

        KErrInUse       an attempt to call Create() for non-empty vector. Close it first.

        KErrArgument    invalid aNumBits value == 0

*/

TInt RBitVector::Create(TUint32 aNumBits)

    {

    if(ipData)

        return KErrInUse; //-- array is already in use. Close it first.

    if(!aNumBits)

        return KErrArgument;

    //-- memory is allocated by word (32 bit) quiantities

    const TUint32 numWords = (aNumBits >> 5) + ((aNumBits & 0x1F) > 0 ? 1:0);

    ipData = (TUint32*)User::AllocZ(numWords << 2);

    if(!ipData)

        return KErrNoMemory;

    iNumBits  = aNumBits;

    iNumWords = numWords;

    return KErrNone;

    }

/**

    Fill a bit vector with a given bit value

    @param aVal a bit value

*/

void RBitVector::Fill(TBool aVal)

    {

    __ASSERT_ALWAYS(ipData, Panic(ENotInitialised));

    memset(ipData, (aVal ? 0xFF : 0x00), iNumWords << 2);

    }

/** Invert all bits in a bit vector */

void RBitVector::Invert()

{

    __ASSERT_ALWAYS(ipData, Panic(ENotInitialised));

    for(TUint32 i=0; i<iNumWords; ++i)

        ipData[i] ^= K_FFFF;

}

/**

    Perform "And" operation between 2 vectors. They shall be the same size.

    @param  aRhs a vector from the right hand side

    @panic ESizeMismatch in the case of different vector sizes

*/

void RBitVector::And(const RBitVector& aRhs)

    {

    __ASSERT_ALWAYS(ipData, Panic(ENotInitialised));

    __ASSERT_ALWAYS(iNumBits == aRhs.iNumBits, Panic(ESizeMismatch));

    for(TUint32 i=0; i<iNumWords; ++i)

        {

        ipData[i] &= aRhs.ipData[i];

        }

    }

/**

    Perform "Or" operation between 2 vectors. They shall be the same size.    

    @param  aRhs a vector from the right hand side

    @panic ESizeMismatch in the case of different vector sizes

*/

void RBitVector::Or(const RBitVector& aRhs)

    {

    __ASSERT_ALWAYS(ipData, Panic(ENotInitialised));

    __ASSERT_ALWAYS(iNumBits == aRhs.iNumBits, Panic(ESizeMismatch));

    for(TUint32 i=0; i<iNumWords; ++i)

        {

        ipData[i] |= aRhs.ipData[i];

        }

    }

/**

    Perform "Xor" operation between 2 vectors. They shall be the same size.    

    @param  aRhs a vector from the right hand side

    @panic ESizeMismatch in the case of different vector sizes

*/

void RBitVector::Xor(const RBitVector& aRhs)

    {

    __ASSERT_ALWAYS(ipData, Panic(ENotInitialised));

    __ASSERT_ALWAYS(iNumBits == aRhs.iNumBits, Panic(ESizeMismatch));

    for(TUint32 i=0; i<iNumWords; ++i)

        {

        ipData[i] ^= aRhs.ipData[i];

        }

    }

//-----------------------------------------------------------------------------

/**

    Fill a range from bit number "aIndexFrom" to "aIndexTo" inclusively with the value of aVal

    @param  aIndexFrom  start bit number (inclusive)

    @param  aIndexTo    end bit number (inclusive)

    @param  aVal        the value to be used to fill the range (0s or 1s)

*/

void RBitVector::Fill(TUint32 aIndexFrom, TUint32 aIndexTo, TBool aVal)

    {

    __ASSERT_ALWAYS(ipData, Panic(ENotInitialised));

    //-- swap indexes if they are not in order

    if(aIndexFrom > aIndexTo)

        {

        const TUint32 tmp = aIndexFrom;

        aIndexFrom = aIndexTo;

        aIndexTo = tmp;

        }

    __ASSERT_ALWAYS((aIndexFrom < iNumBits) && (aIndexTo < iNumBits), Panic(EIndexOutOfRange));

    const TUint32 wordStart = WordNum(aIndexFrom);

    const TUint32 wordTo    = WordNum(aIndexTo);

    if(aVal)

        {//-- filling a range with '1'

        TUint32 shift = BitInWord(aIndexFrom);

        const TUint32 mask1 = (K_FFFF >> shift) << shift;

        TUint32 mask2 = K_FFFF;

        shift = 1+BitInWord(aIndexTo);

        if(shift < 32)

            {

            mask2 = ~((mask2 >> shift) << shift);

            }

        if(wordTo == wordStart)

            {//-- a special case, filling is in the same word

            ipData[wordStart] |= (mask1 & mask2);

            }

        else

            {

            ipData[wordStart] |= mask1; 

            ipData[wordTo]    |= mask2;

            const TUint32 wholeWordsBetween = wordTo - wordStart - 1; //-- whole words that can be bulk filled

            if(wholeWordsBetween)

                memset(ipData+wordStart+1, 0xFF, wholeWordsBetween << 2);

            }

        }

    else

        {//-- filling a range with '0'

        //-- if you need this functionality, remove the panic and uncomment the code below.

        Panic(ENotImplemented);

        /*

        TUint32 shift = BitInWord(aIndexFrom);

        const TUint32 mask1 = ~((K_FFFF >> shift) << shift);

        TUint32 mask2 = 0;

        shift = 1+BitInWord(aIndexTo);

        if(shift < 32)

            {

            mask2 = ((K_FFFF >> shift) << shift);

            }

        if(wordTo == wordStart)

            {//-- a special case, filling is in the same word

            ipData[wordStart] &= (mask1 | mask2);

            }

        else

            {

            ipData[wordStart] &= mask1; 

            ipData[wordTo]    &= mask2;

            const TUint32 wholeWordsBetween = wordTo - wordStart - 1; //-- whole words that can be bulk filled

            if(wholeWordsBetween)

                memset(ipData+wordStart+1, 0x00, wholeWordsBetween << 2);

            }

        */

        }

    }

//-----------------------------------------------------------------------------

/**

    Search for a specified bit value ('0' or '1') in the vector from the given position.

    @param  aStartPos   zero-based index; from this position the search will start. This position isn't included to the search.

                        On return may contain a new position if the specified bit is found in specified direction.

    @param  aBitVal     zero or non-zero bit to search.

    @param  aDir        Specifies the search direction

    @return ETrue if the specified bit value is found; aStartPos gets updated.

            EFalse otherwise.

*/

TBool RBitVector::Find(TUint32& aStartPos, TBool aBitVal, TFindDirection aDir) const

    {

    __ASSERT_ALWAYS(aStartPos < iNumBits, Panic(EIndexOutOfRange));

    ASSERT(iNumWords && ipData);

    switch(aDir)

        {

        case ERight:    //-- Search from the given position to the right

            return FindToRight(aStartPos, aBitVal);

        case ELeft:     //-- Search from the given position to the left (towards lower index)

            return FindToLeft(aStartPos, aBitVal);

        case ENearestL: //-- Search for the nearest value in both directions starting from left

            return FindNearest(aStartPos, aBitVal, ETrue);

        case ENearestR: //-- Search for the nearest value in both directions starting from right

            return FindNearest(aStartPos, aBitVal, EFalse);

        default:

            Panic(EWrondFindDirection);

            return EFalse;

        };

    }

//-----------------------------------------------------------------------------

/**

    Internal method to look for a given bit value in the right direction.

    see TBool RBitVector::Find(...)

*/

TBool RBitVector::FindToRight(TUint32& aStartPos, TBool aBitVal) const

    {

    if(aStartPos >= iNumBits-1)

        return EFalse; //-- no way to the right