/*

 * Copyright (c) 2003-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: 

 *

 */

 #ifndef REMOVE_CAF1

 #include <e32std.h>

 #include <s32strm.h>

 #include <stdarg.h>

 #include <caf/caftypes.h>

 #include <caf/bitset.h>

 using namespace ContentAccess;

 EXPORT_C CBitset* CBitset::NewLC(TInt aMaxBits)

 	{

 	CBitset* self = new(ELeave) CBitset();

 	CleanupStack::PushL(self);

 	self->ConstructL(aMaxBits);

 	return self;

 	}

 EXPORT_C CBitset* CBitset::NewL(TInt aMaxBits)

 	{

 	CBitset* self=CBitset::NewLC(aMaxBits);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CBitset* CBitset::NewLC(const CBitset& aSource)

 	{

 	CBitset* self = new (ELeave) CBitset(aSource);

 	CleanupStack::PushL(self);

 	self->ConstructL(aSource);

 	return self;

 	}

 EXPORT_C CBitset* CBitset::NewL(const CBitset& aSource)

 	{

 	CBitset* self=CBitset::NewLC(aSource);

 	CleanupStack::Pop(self);

 	return self;

 	}

 CBitset::~CBitset() 

 	{ 

 	delete [] iBitSet;

 	}

 CBitset::CBitset()

 	{

 	}

 CBitset::CBitset(const CBitset& aSource)

 	: iWidth(aSource.iWidth), iMaxBits(aSource.iMaxBits)

 	{

 	}

 void CBitset::IdentifyBit(TInt aBitId, // in

 						  TInt &aByte, // out

 						  TInt &aBitInByte) const // out

 	{

 	// Identify the byte & bit corresponding to the Id

 	aByte = aBitId / 8;

 	aBitInByte  = aBitId % 8;

 	}

 EXPORT_C void CBitset::Invert()

 	{

 	// Invert array

 	for (TInt j = 0; j < iWidth ; j++)

 		{

 		iBitSet[j] = static_cast<TUint8> (~iBitSet[j]);

 		}

 	}

 EXPORT_C TInt CBitset::MaxBits() const

 	{

 	return iMaxBits;

 	}

 EXPORT_C void CBitset::Set(TInt aBit)

 	{

 	__ASSERT_ALWAYS(ValidBit(aBit), User::Panic(KCafUtilsPanic, EInvalidBit));

 	TInt targetByte;

 	TInt targetBit;

 	IdentifyBit(aBit, targetByte, targetBit);

 	// Or-in the relevant bit

 	iBitSet[targetByte] |= (1 << targetBit);

 	}

 EXPORT_C void CBitset::Unset(TInt aBit)

 	{

 	__ASSERT_ALWAYS(ValidBit(aBit), User::Panic(KCafUtilsPanic, EInvalidBit));

 	TInt targetByte;

 	TInt targetBit;

 	IdentifyBit(aBit, targetByte, targetBit);

 	// And-in NOT(the relevant bit)

 	iBitSet[targetByte] &= ~(1 << targetBit);

 	}

 EXPORT_C TBool CBitset::IsSet(TInt aBit) const

 	{

 	__ASSERT_ALWAYS(ValidBit(aBit), User::Panic(KCafUtilsPanic, EInvalidBit));

 	TInt targetByte;

 	TInt targetBit;

 	IdentifyBit(aBit, targetByte, targetBit);

 	// And-in the relevant bit and test for non-zero

 	if (iBitSet[targetByte] & (1 << targetBit))

 		{

 		return(ETrue);

 		}

 	else

 		{

 		return(EFalse);

 		}

 	}

 EXPORT_C void CBitset::Reset()

 	{

 	// Reset the array

 	Mem::FillZ(iBitSet, iWidth);

 	}

 EXPORT_C void CBitset::SetAll()

 	{

 	Mem::Fill(iBitSet, iWidth, 0xFF);

 	}

 void CBitset::ConstructL(TInt aMaxBits)

 	{

 	// Calculate the required number of bytes

 	iMaxBits = aMaxBits;

 	iWidth          = 1 + aMaxBits / 8;

 	iBitSet = new (ELeave) TUint8[iWidth];

 	Reset(); // Zero the set

     }

 void CBitset::ConstructL(const CBitset& aSource)

 	{

 	// Copy the bits of the source

 	iBitSet = new (ELeave) TUint8[iWidth];

 	Mem::Copy(iBitSet, aSource.iBitSet, iWidth);

     }

 EXPORT_C void CBitset::ExternalizeL(RWriteStream& aStream) const

 	{

 	// Write the max-Id

 	aStream.WriteInt32L(iMaxBits);

 	// Create a descriptor to encapsulate the set

 	TPtrC8 ptr(iBitSet, iWidth);

 	// Write the descriptor

 	aStream.WriteL(ptr);

 	}

 EXPORT_C void CBitset::InternalizeL(RReadStream& aStream)

 	{

 	// Delete the array 

 	delete [] iBitSet;

 	iBitSet = NULL; // safety

 	// Call the constructor with the max-Id value

 	ConstructL(aStream.ReadInt32L());

 	// Create a descriptor to encapsulate the set

 	TPtr8 ptr(iBitSet, 0, iWidth);

 	// Load into the descriptor

 	aStream.ReadL(ptr);

 	}

 //

 // NB: leavescan will complain that this method calls a leaving

 // function. The Leave is properly documented in the header

 // file. Other than that, not much can be done, especially this

 // class has already been deprecated.

 EXPORT_C CBitset& CBitset::operator=(const CBitset& aSource)

 	{

 	// avoid self-assignment

 	if (this == &aSource)

 		{

 		return *this;

 		}

 	// check for source/dest size mismatch

 	if (aSource.iWidth != iWidth)

 		{

 		// always use largest width

 		TInt widest = iWidth; 

 		if (widest < aSource.iWidth)

 			{

 			widest = aSource.iWidth;

 			}

 		// Malloc the desired width

 		TUint8 *temp = (TUint8 *) new (ELeave) TUint8[widest];

 		// And zero

 		Mem::FillZ(temp, widest);

 		// Now it is safe to re-assign the set

 		delete [] iBitSet;

 		iBitSet = temp;

 		iWidth = widest;

 		}

 	// Width may be the same, but the Max-Id may not, so

 	// align these here

 	iMaxBits = aSource.iMaxBits;

 	// Based on the source-size, copy the bitset

 	Mem::Copy(iBitSet, aSource.iBitSet, aSource.iWidth);

 	return *this;

 	}

 EXPORT_C TBool CBitset::operator==(const CBitset& aSource) const

 	{

 	TBool result = ETrue;

 	if (this == &aSource)

 		{

 		return ETrue;

 		}

 	TInt narrowest = iMaxBits; 

 	if (narrowest > aSource.iMaxBits)

 		{

 		narrowest = aSource.iMaxBits;

 		}

 	// Compare the first "narrowest/8" bytes - if the result is non-zero,

 	// then they are not equal

 	if (Mem::Compare(iBitSet, narrowest/8, aSource.iBitSet, narrowest/8))

 		{

 		return EFalse;

 		}

 	// Now, compare the last set of bits manually

 	for (TInt i = narrowest/8 * 8; i < narrowest; ++i)

 		{

 		// Comparison of booleans - compare their negations

 		if (!IsSet(i) != !aSource.IsSet(i))

 			{

 			return EFalse;

 			}

 		}

 	return result;

 	}

 EXPORT_C void CBitset::SetListL(TInt aItems, ...)

 	{

 	va_list ap;

 	va_start(ap, aItems);

 	// Create a new set (of identical size)

 	CBitset *tempSet = CBitset::NewLC(iMaxBits);

 	// Duplicate this into temporary bitset

 	*tempSet = *this;

 	for (TInt i = 0; i < aItems; i++)

 		{

 		TInt x = va_arg(ap, TInt);

 		tempSet->Set(x);

 		}

 	// No failure, so copy back into this

 	*this = *tempSet;

 	va_end(ap);

 	CleanupStack::Pop(tempSet);

 	delete tempSet;

 	}

 EXPORT_C TBool CBitset::IsSetList(TInt aItems, ...) const

 	{

 	va_list ap;

 	va_start(ap, aItems);

 	for (TInt i = 0; i < aItems; i++)

 		{

 		TInt x = va_arg(ap, TInt);

 		if (!IsSet(x))

 			{

 			return (EFalse);

 			}

 		}

 	va_end(ap);

 	return (ETrue);

 	}

 #endif // #ifndef REMOVE_CAF1