diff -r 000000000000 -r 29b1cd4cb562 bluetooth/btstack/avdtp/avdtpAllocators.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetooth/btstack/avdtp/avdtpAllocators.h	Fri Jan 15 08:13:17 2010 +0200
@@ -0,0 +1,229 @@
+// 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