// 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 "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:

// Defines the avdtp allocators

// These classes help track values that are selected from a pool

// The values are released as R-classes to reflect the "resource ownership"

// that is conferred upon the owner.

// 

//

/**

 @file

 @internalComponent

*/

#ifndef _AVDTPALLOCATORS_H

#define _AVDTPALLOCATORS_H

#include <bluetoothav.h>

#include "gavdpinterface.h"

NONSHARABLE_CLASS(TBitFieldAllocator)

/*

abstract base for types that need to use a bit field to handle their values

*/

	{

friend class RTrackedValue;

protected:

	inline TBitFieldAllocator() : iBitField(0) {};

	TInt Get(TInt& aResult, TInt aMax, TInt aMin=0);

	void Free(TInt aVal);

protected:

	TUint64 iBitField;

	TInt iMin;

	};

NONSHARABLE_CLASS(RTrackedValue)

	{

public:

	inline void Close();

	inline void Acquire(RTrackedValue& aTrackedValue); // this takes ownership

protected:

	inline RTrackedValue();

	inline void Set(TBitFieldAllocator& aAllocator, TUint32 aValue);

protected:

	TBitFieldAllocator* iAllocator; //non-owned

	TUint32 iValue;

private:

	RTrackedValue(const RTrackedValue&); // forbid copying

	RTrackedValue& operator=(const RTrackedValue&);

	};

inline RTrackedValue::RTrackedValue()

: iAllocator(NULL), iValue(0)

	{

	}

inline void RTrackedValue::Set(TBitFieldAllocator& aAllocator, TUint32 aValue)

	{

	iAllocator=&aAllocator;

	iValue=aValue;

	}

inline void RTrackedValue::Close()

	{

	if (iAllocator)

		{

		iAllocator->Free(iValue);

		}

	}

inline void RTrackedValue::Acquire(RTrackedValue& aValue)

	{

	Set(*aValue.iAllocator, aValue.iValue);

	// to transfer ownership:

	new (&aValue) RTrackedValue;

	}

NONSHARABLE_CLASS(RAvdtpTransactionLabel) : public RTrackedValue

	{

friend class TTransactionLabelManager;

public:	

	inline TAvdtpTransactionLabel TransactionLabel() const;

	};

NONSHARABLE_CLASS(RTSID) : public RTrackedValue

	{

friend class TTSIDManager;

public:	

	inline TTSID TSID() const;

	};	

NONSHARABLE_CLASS(RTCID) : public RTrackedValue

	{

friend class TTCIDManager;

public:	

	inline TTCID TCID() const;

	};	

NONSHARABLE_CLASS(RSEID) : public RTrackedValue

	{

friend class TSEIDManager;

public:	

	inline TSEID SEID() const;

	};

inline TAvdtpTransactionLabel RAvdtpTransactionLabel::TransactionLabel() const

	{

	return static_cast<TAvdtpTransactionLabel>(iValue);

	}

inline TTCID RTCID::TCID() const

	{

	return static_cast<TTCID>(iValue);

	}

inline TTSID RTSID::TSID() const

	{

	return static_cast<TTSID>(iValue);

	}

inline TSEID RSEID::SEID() const

	{

	return static_cast<TSEID>(iValue);

	}

NONSHARABLE_CLASS(TTransactionLabelManager) : public TBitFieldAllocator

	{

public:

	inline TInt	GetLabel(RAvdtpTransactionLabel& aLabel);

	};

NONSHARABLE_CLASS(TTCIDManager) : public TBitFieldAllocator

	{

public:

	inline TInt GetTCID(RTCID& aTCID);

	inline TInt GrabTCID(RTCID& aTCID, TTCID aAssignedTCID);

	};

NONSHARABLE_CLASS(TTSIDManager) : public TBitFieldAllocator

	{

public:

	inline TInt GetTSID(RTSID& aTSID);

	};

NONSHARABLE_CLASS(TSEIDManager) : public TBitFieldAllocator

	{

public:

	inline TInt GetSEID(RSEID& aSEID);

	};

inline TInt TTransactionLabelManager::GetLabel(RAvdtpTransactionLabel& aLabel)

	{

	TInt val, res;

	res = Get(val, KMaxTUint5);

	if (res==KErrNone)

		{

		aLabel.Set(*this, val);

		}

	return res;

	}

inline TInt TTCIDManager::GetTCID(RTCID& aTCID)

	{

	TInt val, res;

	res = Get(val, KMaxTUint5-1, KMinimumRealTCID); 	// cannot use top bit as RFD in spec

	if (res==KErrNone)

		{

		aTCID.Set(*this, val);

		}

	return res;

	}

inline TInt TTCIDManager::GrabTCID(RTCID& aTCID, TTCID aAssignedTCID)

	{

	// during muxing the remote can "assign" a TCID from our pool

	// if things are going ok with remote it should be a free TCID

	// but the return allows for an error just in case

	// constrain the range to reuse case-class code :o)

	TInt val, res;

	res = Get(val, aAssignedTCID, aAssignedTCID);

	if (res==KErrNone)

		{

		aTCID.Set(*this, val);

		}

	return res;

	}

inline TInt TTSIDManager::GetTSID(RTSID& aTSID)

	{

	TInt val, res;

	res = Get(val, KMaxTUint5-1, KMinimumRealTSID); 	// cannot use top bit as RFD in spec

	if (res==KErrNone)

		{

		aTSID.Set(*this, val);

		}

	return res;

	}

inline TInt TSEIDManager::GetSEID(RSEID& aSEID)

	{

	TInt val, res;

	// to make agnostic to implementation of local/remote seids

	// remembering this only allocates semantically local seids...

	TSEID min(KMinimumRealSEID, ETrue);

	TSEID max(KMaxTUint6-1, ETrue); // 0x3f is RFD, see 8.18

	__ASSERT_COMPILE(KMinimumRealSEID<KMaxTUint6);

	res = Get(val, max.Value(), min.Value()); 

	if (res==KErrNone)

		{

		aSEID.Set(*this, val);

		}

	return res;

	}

#endif //_AVDTPALLOCATORS_H