Rename BBlockBufferCache and friends to *Pool*

Also move BBlockBufferPoolNoLock into BHPKG namespace with the other
classes. Not sure why it wasn't there before.

headers/build/os/package/BlockBufferCacheNoLock.h

@@ -1 +0,0 @@
-#include <../os/package/BlockBufferCacheNoLock.h>

headers/build/os/package/hpkg/BlockBufferCache.h

@@ -1 +0,0 @@
-#include <../os/package/hpkg/BlockBufferCache.h>

headers/build/os/package/hpkg/BlockBufferPool.h

@@ -0,0 +1 @@
+#include <../os/package/hpkg/BlockBufferPool.h>

headers/build/os/package/hpkg/BlockBufferPoolNoLock.h

@@ -0,0 +1 @@
+#include <../os/package/hpkg/BlockBufferPoolNoLock.h>

headers/build/os/package/hpkg/BufferCache.h

@@ -1 +0,0 @@
-#include <../os/package/hpkg/BufferCache.h>

headers/build/os/package/hpkg/BufferPool.h

@@ -0,0 +1 @@
+#include <../os/package/hpkg/BufferPool.h>

headers/build/private/package/hpkg/BlockBufferCacheImpl.h

@@ -1 +0,0 @@
-#include <../private/package/hpkg/BlockBufferCacheImpl.h>

headers/build/private/package/hpkg/BlockBufferPoolImpl.h

@@ -0,0 +1 @@
+#include <../private/package/hpkg/BlockBufferPoolImpl.h>

headers/build/private/package/hpkg/CachedBuffer.h

@@ -1 +0,0 @@
-#include <../private/package/hpkg/CachedBuffer.h>

headers/build/private/package/hpkg/PoolBuffer.h

@@ -0,0 +1 @@
+#include <../private/package/hpkg/PoolBuffer.h>

headers/os/package/BlockBufferCacheNoLock.h

@@ -1,29 +0,0 @@
-/*
- * Copyright 2009,2011, Haiku, Inc.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _PACKAGE__BLOCK_BUFFER_CACHE_NO_LOCK_H
-#define _PACKAGE__BLOCK_BUFFER_CACHE_NO_LOCK_H
-
-
-#include <package/hpkg/BlockBufferCache.h>
-
-
-namespace BPackageKit {
-
-
-class BBlockBufferCacheNoLock : public BHPKG::BBlockBufferCache {
-public:
-								BBlockBufferCacheNoLock(size_t blockSize,
-									uint32 maxCachedBlocks);
-	virtual						~BBlockBufferCacheNoLock();
-
-	virtual	bool				Lock();
-	virtual	void				Unlock();
-};
-
-
-}	// namespace BPackageKit
-
-
-#endif	// _PACKAGE__BLOCK_BUFFER_CACHE_NO_LOCK_H

headers/os/package/hpkg/BlockBufferCache.h

@@ -1,49 +0,0 @@
-/*
- * Copyright 2009,2011, Haiku, Inc.
- * Distributed under the terms of the MIT License.
- */
-#ifndef _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_
-#define _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_
-
-
-#include <SupportDefs.h>
-
-#include <package/hpkg/BufferCache.h>
-
-
-namespace BPackageKit {
-
-namespace BHPKG {
-
-
-namespace BPrivate {
-	class BlockBufferCacheImpl;
-}
-using BPrivate::BlockBufferCacheImpl;
-
-
-class BBlockBufferCache : public BBufferCache, public BBufferCacheLockable {
-public:
-								BBlockBufferCache(size_t blockSize,
-									uint32 maxCachedBlocks);
-	virtual						~BBlockBufferCache();
-
-	virtual	status_t			Init();
-
-	virtual	CachedBuffer*		GetBuffer(size_t size,
-									CachedBuffer** owner = NULL,
-									bool* _newBuffer = NULL);
-	virtual	void				PutBufferAndCache(CachedBuffer** owner);
-	virtual	void				PutBuffer(CachedBuffer** owner);
-
-private:
-			BlockBufferCacheImpl*	fImpl;
-};
-
-
-}	// namespace BHPKG
-
-}	// namespace BPackageKit
-
-
-#endif	// _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_

headers/os/package/hpkg/BlockBufferPool.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009,2011, Haiku, Inc.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _PACKAGE__HPKG__BLOCK_BUFFER_POOL_H_
+#define _PACKAGE__HPKG__BLOCK_BUFFER_POOL_H_
+
+
+#include <SupportDefs.h>
+
+#include <package/hpkg/BufferPool.h>
+
+
+namespace BPackageKit {
+
+namespace BHPKG {
+
+
+namespace BPrivate {
+	class BlockBufferPoolImpl;
+}
+using BPrivate::BlockBufferPoolImpl;
+
+
+class BBlockBufferPool : public BBufferPool, public BBufferPoolLockable {
+public:
+								BBlockBufferPool(size_t blockSize,
+									uint32 maxCachedBlocks);
+	virtual						~BBlockBufferPool();
+
+	virtual	status_t			Init();
+
+	virtual	PoolBuffer*			GetBuffer(size_t size,
+									PoolBuffer** owner = NULL,
+									bool* _newBuffer = NULL);
+	virtual	void				PutBufferAndCache(PoolBuffer** owner);
+	virtual	void				PutBuffer(PoolBuffer** owner);
+
+private:
+			BlockBufferPoolImpl*	fImpl;
+};
+
+
+}	// namespace BHPKG
+
+}	// namespace BPackageKit
+
+
+#endif	// _PACKAGE__HPKG__BLOCK_BUFFER_POOL_H_

headers/os/package/hpkg/BlockBufferPoolNoLock.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2009,2011, Haiku, Inc.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _PACKAGE__BLOCK_BUFFER_POOL_NO_LOCK_H
+#define _PACKAGE__BLOCK_BUFFER_POOL_NO_LOCK_H
+
+
+#include <package/hpkg/BlockBufferPool.h>
+
+
+namespace BPackageKit {
+
+namespace BHPKG {
+
+
+class BBlockBufferPoolNoLock : public BHPKG::BBlockBufferPool {
+public:
+								BBlockBufferPoolNoLock(size_t blockSize,
+									uint32 maxCachedBlocks);
+	virtual						~BBlockBufferPoolNoLock();
+
+	virtual	bool				Lock();
+	virtual	void				Unlock();
+};
+
+
+}	// namespace BHPKG
+
+}	// namespace BPackageKit
+
+
+#endif	// _PACKAGE__BLOCK_BUFFER_POOL_NO_LOCK_H

headers/os/package/hpkg/BufferPool.h

@@ -2,8 +2,8 @@
  * Copyright 2009,2011, Haiku, Inc.
  * Distributed under the terms of the MIT License.
  */
-#ifndef _PACKAGE__HPKG__BUFFER_CACHE_H_
+#ifndef _PACKAGE__HPKG__BUFFER_POOL_H_
-#define _PACKAGE__HPKG__BUFFER_CACHE_H_
+#define _PACKAGE__HPKG__BUFFER_POOL_H_
 
 
 #include <stddef.h>
@@ -15,31 +15,31 @@ namespace BHPKG {
 
 
 namespace BPrivate {
-	class CachedBuffer;
+	class PoolBuffer;
 }
-using BPrivate::CachedBuffer;
+using BPrivate::PoolBuffer;
 
 
-class BBufferCache {
+class BBufferPool {
 public:
-	virtual						~BBufferCache();
+	virtual						~BBufferPool();
 
-	virtual	CachedBuffer*		GetBuffer(size_t size,
+	virtual	PoolBuffer*			GetBuffer(size_t size,
-									CachedBuffer** owner = NULL,
+									PoolBuffer** owner = NULL,
 									bool* _newBuffer = NULL) = 0;
-	virtual	void				PutBufferAndCache(CachedBuffer** owner) = 0;
+	virtual	void				PutBufferAndCache(PoolBuffer** owner) = 0;
 									// caller is buffer owner and wants the
 									// buffer cached, if possible
-	virtual	void				PutBuffer(CachedBuffer** owner) = 0;
+	virtual	void				PutBuffer(PoolBuffer** owner) = 0;
 									// puts the buffer for good, owner might
 									// have called PutBufferAndCache() before
 									// and might not own a buffer anymore
 };
 
 
-class BBufferCacheLockable {
+class BBufferPoolLockable {
 public:
-	virtual						~BBufferCacheLockable();
+	virtual						~BBufferPoolLockable();
 
 	virtual	bool				Lock() = 0;
 	virtual	void				Unlock() = 0;
@@ -51,4 +51,4 @@ public:
 }	// namespace BPackageKit
 
 
-#endif	// _PACKAGE__HPKG__BUFFER_CACHE_H_
+#endif	// _PACKAGE__HPKG__BUFFER_POOL_H_

headers/os/package/hpkg/PackageDataReader.h

@@ -14,21 +14,21 @@ namespace BPackageKit {
 namespace BHPKG {
 
 
-class BBufferCache;
+class BBufferPool;
 class BPackageData;
 
 
 class BPackageDataReaderFactory {
 public:
 								BPackageDataReaderFactory(
-									BBufferCache* bufferCache);
+									BBufferPool* bufferPool);
 
 			status_t			CreatePackageDataReader(BDataReader* dataReader,
 									const BPackageData& data,
 									BAbstractBufferedDataReader*& _reader);
 
 private:
-			BBufferCache*		fBufferCache;
+			BBufferPool*		fBufferPool;
 };
 
 

headers/os/package/hpkg/v1/PackageDataReader.h

@@ -14,7 +14,7 @@ namespace BPackageKit {
 namespace BHPKG {
 
 
-class BBufferCache;
+class BBufferPool;
 
 
 namespace V1 {
@@ -26,14 +26,14 @@ class BPackageData;
 class BPackageDataReaderFactory {
 public:
 								BPackageDataReaderFactory(
-									BBufferCache* bufferCache);
+									BBufferPool* bufferPool);
 
 			status_t			CreatePackageDataReader(BDataReader* dataReader,
 									const BPackageData& data,
 									BAbstractBufferedDataReader*& _reader);
 
 private:
-			BBufferCache*		fBufferCache;
+			BBufferPool*		fBufferPool;
 };
 
 

headers/private/package/hpkg/BlockBufferCacheImpl.h

@@ -1,67 +0,0 @@
-/*
- * Copyright 2009, Ingo Weinhold, [email protected].
- * Copyright 2011, Oliver Tappe <[email protected]>
- * Distributed under the terms of the MIT License.
- */
-#ifndef _PACKAGE__HPKG__PRIVATE__BLOCK_BUFFER_CACHE_H_
-#define _PACKAGE__HPKG__PRIVATE__BLOCK_BUFFER_CACHE_H_
-
-
-#include <SupportDefs.h>
-
-#include <util/DoublyLinkedList.h>
-
-#include <package/hpkg/BufferCache.h>
-
-
-namespace BPackageKit {
-
-namespace BHPKG {
-
-namespace BPrivate {
-
-
-class CachedBuffer;
-
-
-class BlockBufferCacheImpl : public BBufferCache {
-public:
-								BlockBufferCacheImpl(size_t blockSize,
-									uint32 maxCachedBlocks,
-									BBufferCacheLockable* lockable);
-								~BlockBufferCacheImpl();
-
-			status_t			Init();
-
-			CachedBuffer*		GetBuffer(size_t size,
-									CachedBuffer** owner = NULL,
-									bool* _newBuffer = NULL);
-			void				PutBufferAndCache(CachedBuffer** owner);
-			void				PutBuffer(CachedBuffer** owner);
-
-private:
-			typedef DoublyLinkedList<CachedBuffer> BufferList;
-
-private:
-			CachedBuffer*		_AllocateBuffer(size_t size,
-									CachedBuffer** owner, bool* _newBuffer);
-									// object must not be locked
-
-private:
-			size_t				fBlockSize;
-			uint32				fMaxCachedBlocks;
-			uint32				fAllocatedBlocks;
-			BufferList			fUnusedBuffers;
-			BufferList			fCachedBuffers;
-			BBufferCacheLockable*	fLockable;
-};
-
-
-}	// namespace BPrivate
-
-}	// namespace BHPKG
-
-}	// namespace BPackageKit
-
-
-#endif	// _PACKAGE__HPKG__PRIVATE__BLOCK_BUFFER_CACHE_H_

headers/private/package/hpkg/BlockBufferPoolImpl.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009, Ingo Weinhold, [email protected].
+ * Copyright 2011, Oliver Tappe <[email protected]>
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _PACKAGE__HPKG__PRIVATE__BLOCK_BUFFER_POOL_H_
+#define _PACKAGE__HPKG__PRIVATE__BLOCK_BUFFER_POOL_H_
+
+
+#include <SupportDefs.h>
+
+#include <util/DoublyLinkedList.h>
+
+#include <package/hpkg/BufferPool.h>
+
+
+namespace BPackageKit {
+
+namespace BHPKG {
+
+namespace BPrivate {
+
+
+class PoolBuffer;
+
+
+class BlockBufferPoolImpl : public BBufferPool {
+public:
+								BlockBufferPoolImpl(size_t blockSize,
+									uint32 maxCachedBlocks,
+									BBufferPoolLockable* lockable);
+								~BlockBufferPoolImpl();
+
+			status_t			Init();
+
+			PoolBuffer*			GetBuffer(size_t size,
+									PoolBuffer** owner = NULL,
+									bool* _newBuffer = NULL);
+			void				PutBufferAndCache(PoolBuffer** owner);
+			void				PutBuffer(PoolBuffer** owner);
+
+private:
+			typedef DoublyLinkedList<PoolBuffer> BufferList;
+
+private:
+			PoolBuffer*			_AllocateBuffer(size_t size,
+									PoolBuffer** owner, bool* _newBuffer);
+									// object must not be locked
+
+private:
+			size_t				fBlockSize;
+			uint32				fMaxCachedBlocks;
+			uint32				fAllocatedBlocks;
+			BufferList			fUnusedBuffers;
+			BufferList			fCachedBuffers;
+			BBufferPoolLockable*	fLockable;
+};
+
+
+}	// namespace BPrivate
+
+}	// namespace BHPKG
+
+}	// namespace BPackageKit
+
+
+#endif	// _PACKAGE__HPKG__PRIVATE__BLOCK_BUFFER_POOL_H_

headers/private/package/hpkg/HPKGDefsPrivate.h

@@ -25,6 +25,9 @@ struct hpkg_header {
 	uint16	version;
 	uint64	total_size;
 
+	// heap
+//	uint64	heap_compression;
+
 	// package attributes section
 	uint32	attributes_compression;
 	uint32	attributes_length_compressed;

headers/private/package/hpkg/PoolBuffer.h

@@ -3,15 +3,15 @@
  * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
  * Distributed under the terms of the MIT License.
  */
-#ifndef _PACKAGE__HPKG__PRIVATE__BUFFER_CACHE_H_
+#ifndef _PACKAGE__HPKG__PRIVATE__POOL_BUFFER_H_
-#define _PACKAGE__HPKG__PRIVATE__BUFFER_CACHE_H_
+#define _PACKAGE__HPKG__PRIVATE__POOL_BUFFER_H_
 
 
 #include <stddef.h>
 
 #include <util/DoublyLinkedList.h>
 
-#include <package/hpkg/BufferCache.h>
+#include <package/hpkg/BufferPool.h>
 
 
 namespace BPackageKit {
@@ -21,63 +21,63 @@ namespace BHPKG {
 namespace BPrivate {
 
 
-class CachedBuffer : public DoublyLinkedListLinkImpl<CachedBuffer> {
+class PoolBuffer : public DoublyLinkedListLinkImpl<PoolBuffer> {
 public:
-								CachedBuffer(size_t size);
+								PoolBuffer(size_t size);
-								~CachedBuffer();
+								~PoolBuffer();
 
 			void*				Buffer() const	{ return fBuffer; }
 			size_t				Size() const	{ return fSize; }
 
 
 			// implementation private
-			CachedBuffer**		Owner() const	{ return fOwner; }
+			PoolBuffer**		Owner() const	{ return fOwner; }
-			void				SetOwner(CachedBuffer** owner)
+			void				SetOwner(PoolBuffer** owner)
 									{ fOwner = owner; }
 
 			void				SetCached(bool cached)	{ fCached = cached; }
 			bool				IsCached() const		{ return fCached; }
 
 private:
-			CachedBuffer**		fOwner;
+			PoolBuffer**		fOwner;
 			void*				fBuffer;
 			size_t				fSize;
 			bool				fCached;
 };
 
 
-class CachedBufferPutter {
+class PoolBufferPutter {
 public:
-	CachedBufferPutter(BBufferCache* cache, CachedBuffer** owner)
+	PoolBufferPutter(BBufferPool* pool, PoolBuffer** owner)
 		:
-		fCache(cache),
+		fPool(pool),
 		fOwner(owner),
 		fBuffer(NULL)
 	{
 	}
 
-	CachedBufferPutter(BBufferCache* cache, CachedBuffer* buffer)
+	PoolBufferPutter(BBufferPool* pool, PoolBuffer* buffer)
 		:
-		fCache(cache),
+		fPool(pool),
 		fOwner(NULL),
 		fBuffer(buffer)
 	{
 	}
 
-	~CachedBufferPutter()
+	~PoolBufferPutter()
 	{
-		if (fCache != NULL) {
+		if (fPool != NULL) {
 			if (fOwner != NULL)
-				fCache->PutBufferAndCache(fOwner);
+				fPool->PutBufferAndCache(fOwner);
 			else if (fBuffer != NULL)
-				fCache->PutBuffer(&fBuffer);
+				fPool->PutBuffer(&fBuffer);
 		}
 	}
 
 private:
-	BBufferCache*	fCache;
+	BBufferPool*	fPool;
-	CachedBuffer**	fOwner;
+	PoolBuffer**	fOwner;
-	CachedBuffer*	fBuffer;
+	PoolBuffer*		fBuffer;
 };
 
 
@@ -88,4 +88,4 @@ private:
 }	// namespace BPackageKit
 
 
-#endif	// _PACKAGE__HPKG__PRIVATE__BUFFER_CACHE_H_
+#endif	// _PACKAGE__HPKG__PRIVATE__POOL_BUFFER_H_

src/add-ons/kernel/file_systems/packagefs/Jamfile

@@ -23,7 +23,7 @@ HAIKU_PACKAGE_FS_SOURCES =
 	AttributeDirectoryCookie.cpp
 	AttributeIndex.cpp
 	AutoPackageAttributes.cpp
-	BlockBufferCacheKernel.cpp
+	BlockBufferPoolKernel.cpp
 	DebugSupport.cpp
 	Dependency.cpp
 	Directory.cpp
@@ -70,14 +70,14 @@ HAIKU_PACKAGE_FS_SHARED_SOURCES =
 ;
 
 HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES =
-	BlockBufferCacheImpl.cpp
+	BlockBufferPoolImpl.cpp
-	BufferCache.cpp
+	BufferPool.cpp
-	CachedBuffer.cpp
 	DataOutput.cpp
 	DataReader.cpp
 	ErrorOutput.cpp
 	FDDataReader.cpp
 	HPKGDefs.cpp
+	PoolBuffer.cpp
 	PackageContentHandler.cpp
 	PackageData.cpp
 	PackageDataReader.cpp

src/add-ons/kernel/file_systems/packagefs/package/BlockBufferCacheKernel.cpp

@@ -1,37 +0,0 @@
-/*
- * Copyright 2009, Ingo Weinhold, [email protected].
- * Distributed under the terms of the MIT License.
- */
-
-
-#include "BlockBufferCacheKernel.h"
-
-
-BlockBufferCacheKernel::BlockBufferCacheKernel(size_t blockSize,
-	uint32 maxCachedBlocks)
-	:
-	BlockBufferCacheImpl(blockSize, maxCachedBlocks, this)
-{
-	mutex_init(&fLock, "BlockBufferCache");
-}
-
-
-BlockBufferCacheKernel::~BlockBufferCacheKernel()
-{
-	mutex_destroy(&fLock);
-}
-
-
-bool
-BlockBufferCacheKernel::Lock()
-{
-	mutex_lock(&fLock);
-	return true;
-}
-
-
-void
-BlockBufferCacheKernel::Unlock()
-{
-	mutex_unlock(&fLock);
-}

src/add-ons/kernel/file_systems/packagefs/package/BlockBufferCacheKernel.h

@@ -1,34 +0,0 @@
-/*
- * Copyright 2009, Ingo Weinhold, [email protected].
- * Distributed under the terms of the MIT License.
- */
-#ifndef BLOCK_BUFFER_CACHE_KERNEL_H
-#define BLOCK_BUFFER_CACHE_KERNEL_H
-
-
-#include <lock.h>
-
-#include <package/hpkg/BlockBufferCacheImpl.h>
-#include <package/hpkg/BufferCache.h>
-
-
-using BPackageKit::BHPKG::BBufferCacheLockable;
-using BPackageKit::BHPKG::BPrivate::BlockBufferCacheImpl;
-
-
-class BlockBufferCacheKernel
-	: public BlockBufferCacheImpl, BBufferCacheLockable {
-public:
-								BlockBufferCacheKernel(size_t blockSize,
-									uint32 maxCachedBlocks);
-	virtual						~BlockBufferCacheKernel();
-
-	virtual	bool				Lock();
-	virtual	void				Unlock();
-
-private:
-			mutex				fLock;
-};
-
-
-#endif	// BLOCK_BUFFER_CACHE_KERNEL_H

src/add-ons/kernel/file_systems/packagefs/package/BlockBufferPoolKernel.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2009, Ingo Weinhold, [email protected].
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include "BlockBufferPoolKernel.h"
+
+
+BlockBufferPoolKernel::BlockBufferPoolKernel(size_t blockSize,
+	uint32 maxCachedBlocks)
+	:
+	BlockBufferPoolImpl(blockSize, maxCachedBlocks, this)
+{
+	mutex_init(&fLock, "BlockBufferPool");
+}
+
+
+BlockBufferPoolKernel::~BlockBufferPoolKernel()
+{
+	mutex_destroy(&fLock);
+}
+
+
+bool
+BlockBufferPoolKernel::Lock()
+{
+	mutex_lock(&fLock);
+	return true;
+}
+
+
+void
+BlockBufferPoolKernel::Unlock()
+{
+	mutex_unlock(&fLock);
+}

src/add-ons/kernel/file_systems/packagefs/package/BlockBufferPoolKernel.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2009, Ingo Weinhold, [email protected].
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef BLOCK_BUFFER_POOL_KERNEL_H
+#define BLOCK_BUFFER_POOL_KERNEL_H
+
+
+#include <lock.h>
+
+#include <package/hpkg/BlockBufferPoolImpl.h>
+#include <package/hpkg/BufferPool.h>
+
+
+using BPackageKit::BHPKG::BBufferPoolLockable;
+using BPackageKit::BHPKG::BPrivate::BlockBufferPoolImpl;
+
+
+class BlockBufferPoolKernel : public BlockBufferPoolImpl, BBufferPoolLockable {
+public:
+								BlockBufferPoolKernel(size_t blockSize,
+									uint32 maxCachedBlocks);
+	virtual						~BlockBufferPoolKernel();
+
+	virtual	bool				Lock();
+	virtual	void				Unlock();
+
+private:
+			mutex				fLock;
+};
+
+
+#endif	// BLOCK_BUFFER_POOL_KERNEL_H

src/add-ons/kernel/file_systems/packagefs/package/GlobalFactory.cpp

@@ -20,10 +20,10 @@ static const uint32 kMaxCachedBuffers = 32;
 
 GlobalFactory::GlobalFactory()
 	:
-	fBufferCache(BPackageKit::BHPKG::B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB,
+	fBufferPool(BPackageKit::BHPKG::B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB,
 		kMaxCachedBuffers),
-	fPackageDataReaderFactoryV1(&fBufferCache),
+	fPackageDataReaderFactoryV1(&fBufferPool),
-	fPackageDataReaderFactoryV2(&fBufferCache)
+	fPackageDataReaderFactoryV2(&fBufferPool)
 {
 	STATIC_ASSERT((int)BPackageKit::BHPKG::B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB
 		== (int)BPackageKit::BHPKG::V1::B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB);
@@ -93,7 +93,7 @@ GlobalFactory::CreatePackageDataReader(BDataReader* dataReader,
 status_t
 GlobalFactory::_Init()
 {
-	status_t error = fBufferCache.Init();
+	status_t error = fBufferPool.Init();
 	if (error != B_OK)
 		return error;
 

src/add-ons/kernel/file_systems/packagefs/package/GlobalFactory.h

@@ -9,7 +9,7 @@
 #include <package/hpkg/PackageDataReader.h>
 #include <package/hpkg/v1/PackageDataReader.h>
 
-#include "BlockBufferCacheKernel.h"
+#include "BlockBufferPoolKernel.h"
 
 
 using BPackageKit::BHPKG::BDataReader;
@@ -44,7 +44,7 @@ private:
 private:
 	static	GlobalFactory*		sDefaultInstance;
 
-			BlockBufferCacheKernel fBufferCache;
+			BlockBufferPoolKernel fBufferPool;
 			BPackageDataReaderFactoryV1 fPackageDataReaderFactoryV1;
 			BPackageDataReaderFactoryV2 fPackageDataReaderFactoryV2;
 };

src/bin/package/command_extract.cpp

@@ -25,7 +25,7 @@
 
 #include <util/OpenHashTable.h>
 
-#include <package/BlockBufferCacheNoLock.h>
+#include <package/hpkg/BlockBufferPoolNoLock.h>
 #include <package/hpkg/PackageContentHandler.h>
 #include <package/hpkg/PackageDataReader.h>
 #include <package/hpkg/PackageEntry.h>
@@ -41,8 +41,8 @@
 #include "package.h"
 
 
-using BPackageKit::BBlockBufferCacheNoLock;
 using BPackageKit::BHPKG::BAbstractBufferedDataReader;
+using BPackageKit::BHPKG::BBlockBufferPoolNoLock;
 using BPackageKit::BHPKG::BBufferDataReader;
 using BPackageKit::BHPKG::BDataReader;
 using BPackageKit::BHPKG::BFDDataReader;
@@ -229,7 +229,7 @@ template<typename VersionPolicy>
 struct PackageContentExtractHandler : VersionPolicy::PackageContentHandler {
 	PackageContentExtractHandler(int packageFileFD)
 		:
-		fBufferCache(VersionPolicy::kDefaultDataChunkSize, 2),
+		fBufferPool(VersionPolicy::kDefaultDataChunkSize, 2),
 		fPackageFileReader(packageFileFD),
 		fDataBuffer(NULL),
 		fDataBufferSize(0),
@@ -247,7 +247,7 @@ struct PackageContentExtractHandler : VersionPolicy::PackageContentHandler {
 
 	status_t Init()
 	{
-		status_t error = fBufferCache.Init();
+		status_t error = fBufferPool.Init();
 		if (error != B_OK)
 			return error;
 
@@ -648,7 +648,7 @@ private:
 		// create a PackageDataReader
 		BAbstractBufferedDataReader* reader;
 		status_t error = typename VersionPolicy::PackageDataReaderFactory(
-				&fBufferCache)
+				&fBufferPool)
 			.CreatePackageDataReader(dataReader, data, reader);
 		if (error != B_OK)
 			return error;
@@ -688,7 +688,7 @@ private:
 	}
 
 private:
-	BBlockBufferCacheNoLock	fBufferCache;
+	BBlockBufferPoolNoLock	fBufferPool;
 	BFDDataReader			fPackageFileReader;
 	void*					fDataBuffer;
 	size_t					fDataBufferSize;

src/build/libpackage/Jamfile

@@ -21,10 +21,11 @@ USES_BE_API on libpackage_build.so = true ;
 
 HPKG_SOURCES =
 	AttributeDataReader.cpp
-	BlockBufferCache.cpp
+	BlockBufferPool.cpp
-	BlockBufferCacheImpl.cpp
+	BlockBufferPoolImpl.cpp
-	BufferCache.cpp
+	BlockBufferPoolNoLock.cpp
-	CachedBuffer.cpp
+	BufferPool.cpp
+	PoolBuffer.cpp
 	DataOutput.cpp
 	DataReader.cpp
 	ErrorOutput.cpp
@@ -75,7 +76,6 @@ BuildPlatformSharedLibrary libpackage_build.so
 	ActivationTransaction.cpp
 	AddRepositoryRequest.cpp
 	Attributes.cpp
-	BlockBufferCacheNoLock.cpp
 	ChecksumAccessors.cpp
 	Context.cpp
 	DownloadFileRequest.cpp

src/kits/package/BlockBufferCacheNoLock.cpp

@@ -1,40 +0,0 @@
-/*
- * Copyright 2009, Ingo Weinhold, [email protected].
- * Copyright 2011, Oliver Tappe <[email protected]>
- * Distributed under the terms of the MIT License.
- */
-
-
-#include <package/BlockBufferCacheNoLock.h>
-
-
-namespace BPackageKit {
-
-
-BBlockBufferCacheNoLock::BBlockBufferCacheNoLock(size_t blockSize,
-	uint32 maxCachedBlocks)
-	:
-	BBlockBufferCache(blockSize, maxCachedBlocks)
-{
-}
-
-
-BBlockBufferCacheNoLock::~BBlockBufferCacheNoLock()
-{
-}
-
-
-bool
-BBlockBufferCacheNoLock::Lock()
-{
-	return true;
-}
-
-
-void
-BBlockBufferCacheNoLock::Unlock()
-{
-}
-
-
-}	// namespace BPackageKit

src/kits/package/Jamfile

@@ -12,10 +12,10 @@ SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package solver ] ;
 
 HPKG_SOURCES =
 	AttributeDataReader.cpp
-	BlockBufferCache.cpp
+	BlockBufferPool.cpp
-	BlockBufferCacheImpl.cpp
+	BlockBufferPoolImpl.cpp
-	BufferCache.cpp
+	BlockBufferPoolNoLock.cpp
-	CachedBuffer.cpp
+	BufferPool.cpp
 	DataOutput.cpp
 	DataReader.cpp
 	ErrorOutput.cpp
@@ -26,10 +26,12 @@ HPKG_SOURCES =
 	PackageDataReader.cpp
 	PackageEntry.cpp
 	PackageEntryAttribute.cpp
+	PackageFileHeapWriter.cpp
 	PackageReader.cpp
 	PackageReaderImpl.cpp
 	PackageWriter.cpp
 	PackageWriterImpl.cpp
+	PoolBuffer.cpp
 	ReaderImplBase.cpp
 	RepositoryReader.cpp
 	RepositoryReaderImpl.cpp
@@ -66,7 +68,6 @@ SharedLibrary libpackage.so
 	ActivationTransaction.cpp
 	AddRepositoryRequest.cpp
 	Attributes.cpp
-	BlockBufferCacheNoLock.cpp
 	ChecksumAccessors.cpp
 	Context.cpp
 	DaemonClient.cpp

src/kits/package/hpkg/BlockBufferPool.cpp

@@ -4,11 +4,11 @@
  */
 
 
-#include <package/hpkg/BlockBufferCache.h>
+#include <package/hpkg/BlockBufferPool.h>
 
 #include <new>
 
-#include <package/hpkg/BlockBufferCacheImpl.h>
+#include <package/hpkg/BlockBufferPoolImpl.h>
 
 
 namespace BPackageKit {
@@ -16,22 +16,22 @@ namespace BPackageKit {
 namespace BHPKG {
 
 
-BBlockBufferCache::BBlockBufferCache(size_t blockSize, uint32 maxCachedBlocks)
+BBlockBufferPool::BBlockBufferPool(size_t blockSize, uint32 maxCachedBlocks)
 	:
-	fImpl(new (std::nothrow) BlockBufferCacheImpl(blockSize, maxCachedBlocks,
+	fImpl(new (std::nothrow) BlockBufferPoolImpl(blockSize, maxCachedBlocks,
 		this))
 {
 }
 
 
-BBlockBufferCache::~BBlockBufferCache()
+BBlockBufferPool::~BBlockBufferPool()
 {
 	delete fImpl;
 }
 
 
 status_t
-BBlockBufferCache::Init()
+BBlockBufferPool::Init()
 {
 	if (fImpl == NULL)
 		return B_NO_MEMORY;
@@ -40,8 +40,8 @@ BBlockBufferCache::Init()
 }
 
 
-CachedBuffer*
+PoolBuffer*
-BBlockBufferCache::GetBuffer(size_t size, CachedBuffer** owner,
+BBlockBufferPool::GetBuffer(size_t size, PoolBuffer** owner,
 	bool* _newBuffer)
 {
 	if (fImpl == NULL)
@@ -52,7 +52,7 @@ BBlockBufferCache::GetBuffer(size_t size, CachedBuffer** owner,
 
 
 void
-BBlockBufferCache::PutBufferAndCache(CachedBuffer** owner)
+BBlockBufferPool::PutBufferAndCache(PoolBuffer** owner)
 {
 	if (fImpl != NULL)
 		fImpl->PutBufferAndCache(owner);
@@ -60,7 +60,7 @@ BBlockBufferCache::PutBufferAndCache(CachedBuffer** owner)
 
 
 void
-BBlockBufferCache::PutBuffer(CachedBuffer** owner)
+BBlockBufferPool::PutBuffer(PoolBuffer** owner)
 {
 	if (fImpl != NULL)
 		fImpl->PutBuffer(owner);

src/kits/package/hpkg/BlockBufferPoolImpl.cpp

@@ -5,14 +5,14 @@
  */
 
 
-#include <package/hpkg/BlockBufferCacheImpl.h>
+#include <package/hpkg/BlockBufferPoolImpl.h>
 
 #include <algorithm>
 #include <new>
 
 #include <AutoLocker.h>
 
-#include <package/hpkg/CachedBuffer.h>
+#include <package/hpkg/PoolBuffer.h>
 
 
 namespace BPackageKit {
@@ -22,11 +22,11 @@ namespace BHPKG {
 namespace BPrivate {
 
 
-// #pragma mark - BlockBufferCacheImpl
+// #pragma mark - BlockBufferPoolImpl
 
 
-BlockBufferCacheImpl::BlockBufferCacheImpl(size_t blockSize,
+BlockBufferPoolImpl::BlockBufferPoolImpl(size_t blockSize,
-	uint32 maxCachedBlocks, BBufferCacheLockable* lockable)
+	uint32 maxCachedBlocks, BBufferPoolLockable* lockable)
 	:
 	fBlockSize(blockSize),
 	fMaxCachedBlocks(maxCachedBlocks),
@@ -36,36 +36,36 @@ BlockBufferCacheImpl::BlockBufferCacheImpl(size_t blockSize,
 }
 
 
-BlockBufferCacheImpl::~BlockBufferCacheImpl()
+BlockBufferPoolImpl::~BlockBufferPoolImpl()
 {
 	// delete all cached blocks
-	while (CachedBuffer* block = fCachedBuffers.RemoveHead())
+	while (PoolBuffer* block = fCachedBuffers.RemoveHead())
 		delete block;
 
-	while (CachedBuffer* block = fUnusedBuffers.RemoveHead())
+	while (PoolBuffer* block = fUnusedBuffers.RemoveHead())
 		delete block;
 }
 
 
 status_t
-BlockBufferCacheImpl::Init()
+BlockBufferPoolImpl::Init()
 {
 	return B_OK;
 }
 
 
-CachedBuffer*
+PoolBuffer*
-BlockBufferCacheImpl::GetBuffer(size_t size, CachedBuffer** owner, bool* _newBuffer)
+BlockBufferPoolImpl::GetBuffer(size_t size, PoolBuffer** owner, bool* _newBuffer)
 {
 	// for sizes greater than the block size, we always allocate a new buffer
 	if (size > fBlockSize)
 		return _AllocateBuffer(size, owner, _newBuffer);
 
-	AutoLocker<BBufferCacheLockable> locker(fLockable);
+	AutoLocker<BBufferPoolLockable> locker(fLockable);
 
 	// if an owner is given and the buffer is still cached, return it
 	if (owner != NULL && *owner != NULL) {
-		CachedBuffer* buffer = *owner;
+		PoolBuffer* buffer = *owner;
 		fCachedBuffers.Remove(buffer);
 
 		if (_newBuffer != NULL)
@@ -74,7 +74,7 @@ BlockBufferCacheImpl::GetBuffer(size_t size, CachedBuffer** owner, bool* _newBuf
 	}
 
 	// we need a new buffer -- try unused ones first
-	CachedBuffer* buffer = fUnusedBuffers.RemoveHead();
+	PoolBuffer* buffer = fUnusedBuffers.RemoveHead();
 	if (buffer != NULL) {
 		buffer->SetOwner(owner);
 
@@ -108,9 +108,9 @@ BlockBufferCacheImpl::GetBuffer(size_t size, CachedBuffer** owner, bool* _newBuf
 
 
 void
-BlockBufferCacheImpl::PutBufferAndCache(CachedBuffer** owner)
+BlockBufferPoolImpl::PutBufferAndCache(PoolBuffer** owner)
 {
-	CachedBuffer* buffer = *owner;
+	PoolBuffer* buffer = *owner;
 
 	// always delete buffers with non-standard size
 	if (buffer->Size() != fBlockSize) {
@@ -119,7 +119,7 @@ BlockBufferCacheImpl::PutBufferAndCache(CachedBuffer** owner)
 		return;
 	}
 
-	AutoLocker<BBufferCacheLockable> locker(fLockable);
+	AutoLocker<BBufferPoolLockable> locker(fLockable);
 
 	// queue the cached buffer
 	buffer->SetOwner(owner);
@@ -128,7 +128,7 @@ BlockBufferCacheImpl::PutBufferAndCache(CachedBuffer** owner)
 
 	if (fAllocatedBlocks > fMaxCachedBlocks) {
 		// We have exceeded the limit -- we need to free a buffer.
-		CachedBuffer* otherBuffer = fUnusedBuffers.RemoveHead();
+		PoolBuffer* otherBuffer = fUnusedBuffers.RemoveHead();
 		if (otherBuffer == NULL) {
 			otherBuffer = fCachedBuffers.RemoveHead();
 			*otherBuffer->Owner() = NULL;
@@ -141,11 +141,11 @@ BlockBufferCacheImpl::PutBufferAndCache(CachedBuffer** owner)
 
 
 void
-BlockBufferCacheImpl::PutBuffer(CachedBuffer** owner)
+BlockBufferPoolImpl::PutBuffer(PoolBuffer** owner)
 {
-	AutoLocker<BBufferCacheLockable> locker(fLockable);
+	AutoLocker<BBufferPoolLockable> locker(fLockable);
 
-	CachedBuffer* buffer = *owner;
+	PoolBuffer* buffer = *owner;
 
 	if (buffer == NULL)
 		return;
@@ -165,11 +165,11 @@ BlockBufferCacheImpl::PutBuffer(CachedBuffer** owner)
 }
 
 
-CachedBuffer*
+PoolBuffer*
-BlockBufferCacheImpl::_AllocateBuffer(size_t size, CachedBuffer** owner,
+BlockBufferPoolImpl::_AllocateBuffer(size_t size, PoolBuffer** owner,
 	bool* _newBuffer)
 {
-	CachedBuffer* buffer = new(std::nothrow) CachedBuffer(
+	PoolBuffer* buffer = new(std::nothrow) PoolBuffer(
 		std::max(size, fBlockSize));
 	if (buffer == NULL || buffer->Buffer() == NULL) {
 		delete buffer;
@@ -181,7 +181,7 @@ BlockBufferCacheImpl::_AllocateBuffer(size_t size, CachedBuffer** owner,
 	if (_newBuffer != NULL)
 		*_newBuffer = true;
 
-	AutoLocker<BBufferCacheLockable> locker(fLockable);
+	AutoLocker<BBufferPoolLockable> locker(fLockable);
 	fAllocatedBlocks++;
 
 	if (owner != NULL)

src/kits/package/hpkg/BlockBufferPoolNoLock.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009, Ingo Weinhold, [email protected].
+ * Copyright 2011, Oliver Tappe <[email protected]>
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include <package/hpkg/BlockBufferPoolNoLock.h>
+
+
+namespace BPackageKit {
+
+namespace BHPKG {
+
+
+BBlockBufferPoolNoLock::BBlockBufferPoolNoLock(size_t blockSize,
+	uint32 maxCachedBlocks)
+	:
+	BBlockBufferPool(blockSize, maxCachedBlocks)
+{
+}
+
+
+BBlockBufferPoolNoLock::~BBlockBufferPoolNoLock()
+{
+}
+
+
+bool
+BBlockBufferPoolNoLock::Lock()
+{
+	return true;
+}
+
+
+void
+BBlockBufferPoolNoLock::Unlock()
+{
+}
+
+
+}	// namespace BHPKG
+
+}	// namespace BPackageKit

src/kits/package/hpkg/BufferPool.cpp

@@ -4,7 +4,7 @@
  */
 
 
-#include <package/hpkg/BufferCache.h>
+#include <package/hpkg/BufferPool.h>
 
 
 namespace BPackageKit {
@@ -12,12 +12,12 @@ namespace BPackageKit {
 namespace BHPKG {
 
 
-BBufferCache::~BBufferCache()
+BBufferPool::~BBufferPool()
 {
 }
 
 
-BBufferCacheLockable::~BBufferCacheLockable()
+BBufferPoolLockable::~BBufferPoolLockable()
 {
 }
 

src/kits/package/hpkg/PackageDataReader.cpp

@@ -12,8 +12,8 @@
 #include <new>
 
 #include <package/hpkg/HPKGDefsPrivate.h>
-#include <package/hpkg/BufferCache.h>
+#include <package/hpkg/BufferPool.h>
-#include <package/hpkg/CachedBuffer.h>
+#include <package/hpkg/PoolBuffer.h>
 #include <package/hpkg/DataOutput.h>
 #include <package/hpkg/PackageData.h>
 #include <package/hpkg/ZlibDecompressor.h>
@@ -66,10 +66,10 @@ protected:
 class UncompressedPackageDataReader : public PackageDataReader {
 public:
 	UncompressedPackageDataReader(BDataReader* dataReader,
-		BBufferCache* bufferCache)
+		BBufferPool* bufferPool)
 		:
 		PackageDataReader(dataReader),
-		fBufferCache(bufferCache)
+		fBufferPool(bufferPool)
 	{
 	}
 
@@ -107,11 +107,11 @@ public:
 			return B_BAD_VALUE;
 
 		// get a temporary buffer
-		CachedBuffer* buffer = fBufferCache->GetBuffer(
+		PoolBuffer* buffer = fBufferPool->GetBuffer(
 			kUncompressedReaderBufferSize);
 		if (buffer == NULL)
 			return B_NO_MEMORY;
-		CachedBufferPutter bufferPutter(fBufferCache, &buffer);
+		PoolBufferPutter bufferPutter(fBufferPool, &buffer);
 
 		while (size > 0) {
 			// read into the buffer
@@ -134,7 +134,7 @@ public:
 	}
 
 private:
-	BBufferCache*	fBufferCache;
+	BBufferPool*	fBufferPool;
 	uint64			fOffset;
 	uint64			fSize;
 };
@@ -145,10 +145,10 @@ private:
 
 class ZlibPackageDataReader : public PackageDataReader {
 public:
-	ZlibPackageDataReader(BDataReader* dataReader, BBufferCache* bufferCache)
+	ZlibPackageDataReader(BDataReader* dataReader, BBufferPool* bufferPool)
 		:
 		PackageDataReader(dataReader),
-		fBufferCache(bufferCache),
+		fBufferPool(bufferPool),
 		fUncompressBuffer(NULL),
 		fOffsetTable(NULL)
 	{
@@ -158,7 +158,7 @@ public:
 	{
 		delete[] fOffsetTable;
 
-		fBufferCache->PutBuffer(&fUncompressBuffer);
+		fBufferPool->PutBuffer(&fUncompressBuffer);
 	}
 
 	status_t Init(const BPackageData& data)
@@ -218,11 +218,11 @@ public:
 
 		// get our uncompressed chunk buffer back, if possible
 		bool newBuffer;
-		if (fBufferCache->GetBuffer(fChunkSize, &fUncompressBuffer, &newBuffer)
+		if (fBufferPool->GetBuffer(fChunkSize, &fUncompressBuffer, &newBuffer)
 				== NULL) {
 			return B_NO_MEMORY;
 		}
-		CachedBufferPutter uncompressBufferPutter(fBufferCache,
+		PoolBufferPutter uncompressBufferPutter(fBufferPool,
 			&fUncompressBuffer);
 
 		if (newBuffer)
@@ -281,10 +281,10 @@ private:
 				compressedSize);
 		} else {
 			// read to a read buffer and uncompress
-			CachedBuffer* readBuffer = fBufferCache->GetBuffer(fChunkSize);
+			PoolBuffer* readBuffer = fBufferPool->GetBuffer(fChunkSize);
 			if (readBuffer == NULL)
 				return B_NO_MEMORY;
-			CachedBufferPutter readBufferPutter(fBufferCache, readBuffer);
+			PoolBufferPutter readBufferPutter(fBufferPool, readBuffer);
 
 			error = fDataReader->ReadData(offset, readBuffer->Buffer(),
 				compressedSize);
@@ -378,8 +378,8 @@ private:
 	}
 
 private:
-	BBufferCache*	fBufferCache;
+	BBufferPool*	fBufferPool;
-	CachedBuffer*	fUncompressBuffer;
+	PoolBuffer*		fUncompressBuffer;
 	int64			fUncompressedChunk;
 
 	uint64			fOffset;
@@ -397,9 +397,9 @@ private:
 // #pragma mark - BPackageDataReaderFactory
 
 
-BPackageDataReaderFactory::BPackageDataReaderFactory(BBufferCache* bufferCache)
+BPackageDataReaderFactory::BPackageDataReaderFactory(BBufferPool* bufferPool)
 	:
-	fBufferCache(bufferCache)
+	fBufferPool(bufferPool)
 {
 }
 
@@ -413,11 +413,11 @@ BPackageDataReaderFactory::CreatePackageDataReader(BDataReader* dataReader,
 	switch (data.Compression()) {
 		case B_HPKG_COMPRESSION_NONE:
 			reader = new(std::nothrow) UncompressedPackageDataReader(
-				dataReader, fBufferCache);
+				dataReader, fBufferPool);
 			break;
 		case B_HPKG_COMPRESSION_ZLIB:
 			reader = new(std::nothrow) ZlibPackageDataReader(dataReader,
-				fBufferCache);
+				fBufferPool);
 			break;
 		default:
 			return B_BAD_VALUE;

src/kits/package/hpkg/PackageWriterImpl.cpp

@@ -26,8 +26,7 @@
 #include <fs_attr.h>
 #include <Path.h>
 
-#include <package/BlockBufferCacheNoLock.h>
+#include <package/hpkg/BlockBufferPoolNoLock.h>
-
 #include <package/hpkg/PackageAttributeValue.h>
 #include <package/hpkg/PackageContentHandler.h>
 #include <package/hpkg/PackageData.h>
@@ -879,7 +878,7 @@ PackageWriterImpl::_UpdateReadPackageInfo()
 		memcpy(valueBuffer, value.data.raw, value.data.size);
 	} else {
 		// data on heap -- read from there
-		BBlockBufferCacheNoLock	bufferCache(16 * 1024, 1);
+		BBlockBufferPoolNoLock	bufferCache(16 * 1024, 1);
 		status_t error = bufferCache.Init();
 		if (error != B_OK) {
 			fListener->PrintError("Failed to initialize buffer cache: %s\n",

src/kits/package/hpkg/PoolBuffer.cpp

@@ -4,7 +4,7 @@
  */
 
 
-#include <package/hpkg/CachedBuffer.h>
+#include <package/hpkg/PoolBuffer.h>
 
 #include <stdlib.h>
 
@@ -16,7 +16,7 @@ namespace BHPKG {
 namespace BPrivate {
 
 
-CachedBuffer::CachedBuffer(size_t size)
+PoolBuffer::PoolBuffer(size_t size)
 	:
 	fOwner(NULL),
 	fBuffer(malloc(size)),
@@ -26,7 +26,7 @@ CachedBuffer::CachedBuffer(size_t size)
 }
 
 
-CachedBuffer::~CachedBuffer()
+PoolBuffer::~PoolBuffer()
 {
 	free(fBuffer);
 }

src/kits/package/hpkg/RepositoryWriterImpl.cpp

@@ -16,12 +16,12 @@
 #include <AutoDeleter.h>
 #include <HashSet.h>
 
+#include <package/hpkg/BlockBufferPoolNoLock.h>
 #include <package/hpkg/HPKGDefsPrivate.h>
 #include <package/hpkg/PackageDataReader.h>
 #include <package/hpkg/PackageEntry.h>
 #include <package/hpkg/PackageInfoAttributeValue.h>
 #include <package/hpkg/PackageReader.h>
-#include <package/BlockBufferCacheNoLock.h>
 #include <package/ChecksumAccessors.h>
 #include <package/HashableString.h>
 #include <package/PackageInfoContentHandler.h>
@@ -47,7 +47,7 @@ struct PackageEntryDataFetcher {
 		BPackageData& packageData)
 		:
 		fErrorOutput(errorOutput),
-		fBufferCache(B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB, 2),
+		fBufferPool(B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB, 2),
 		fPackageData(packageData)
 	{
 	}
@@ -56,7 +56,7 @@ struct PackageEntryDataFetcher {
 	{
 		// create a PackageDataReader
 		BAbstractBufferedDataReader* reader;
-		status_t result = BPackageDataReaderFactory(&fBufferCache)
+		status_t result = BPackageDataReaderFactory(&fBufferPool)
 			.CreatePackageDataReader(dataReader, fPackageData, reader);
 		if (result != B_OK)
 			return result;
@@ -81,7 +81,7 @@ struct PackageEntryDataFetcher {
 
 private:
 	BErrorOutput*			fErrorOutput;
-	BBlockBufferCacheNoLock fBufferCache;
+	BBlockBufferPoolNoLock	fBufferPool;
 	BPackageData&			fPackageData;
 };
 

src/kits/package/hpkg/v1/PackageDataReaderV1.cpp

@@ -11,8 +11,8 @@
 #include <algorithm>
 #include <new>
 
-#include <package/hpkg/BufferCache.h>
+#include <package/hpkg/BufferPool.h>
-#include <package/hpkg/CachedBuffer.h>
+#include <package/hpkg/PoolBuffer.h>
 #include <package/hpkg/DataOutput.h>
 #include <package/hpkg/v1/HPKGDefsPrivate.h>
 #include <package/hpkg/v1/PackageData.h>
@@ -26,7 +26,7 @@ namespace BHPKG {
 namespace V1 {
 
 
-using BHPKG::BPrivate::CachedBufferPutter;
+using BHPKG::BPrivate::PoolBufferPutter;
 using BHPKG::BPrivate::ZlibDecompressor;
 
 
@@ -69,10 +69,10 @@ protected:
 class UncompressedPackageDataReader : public PackageDataReader {
 public:
 	UncompressedPackageDataReader(BDataReader* dataReader,
-		BBufferCache* bufferCache)
+		BBufferPool* bufferPool)
 		:
 		PackageDataReader(dataReader),
-		fBufferCache(bufferCache)
+		fBufferPool(bufferPool)
 	{
 	}
 
@@ -110,11 +110,11 @@ public:
 			return B_BAD_VALUE;
 
 		// get a temporary buffer
-		CachedBuffer* buffer = fBufferCache->GetBuffer(
+		PoolBuffer* buffer = fBufferPool->GetBuffer(
 			kUncompressedReaderBufferSize);
 		if (buffer == NULL)
 			return B_NO_MEMORY;
-		CachedBufferPutter bufferPutter(fBufferCache, &buffer);
+		PoolBufferPutter bufferPutter(fBufferPool, &buffer);
 
 		while (size > 0) {
 			// read into the buffer
@@ -137,7 +137,7 @@ public:
 	}
 
 private:
-	BBufferCache*	fBufferCache;
+	BBufferPool*	fBufferPool;
 	uint64			fOffset;
 	uint64			fSize;
 };
@@ -148,10 +148,10 @@ private:
 
 class ZlibPackageDataReader : public PackageDataReader {
 public:
-	ZlibPackageDataReader(BDataReader* dataReader, BBufferCache* bufferCache)
+	ZlibPackageDataReader(BDataReader* dataReader, BBufferPool* bufferPool)
 		:
 		PackageDataReader(dataReader),
-		fBufferCache(bufferCache),
+		fBufferPool(bufferPool),
 		fUncompressBuffer(NULL),
 		fOffsetTable(NULL)
 	{
@@ -161,7 +161,7 @@ public:
 	{
 		delete[] fOffsetTable;
 
-		fBufferCache->PutBuffer(&fUncompressBuffer);
+		fBufferPool->PutBuffer(&fUncompressBuffer);
 	}
 
 	status_t Init(const BPackageData& data)
@@ -221,11 +221,11 @@ public:
 
 		// get our uncompressed chunk buffer back, if possible
 		bool newBuffer;
-		if (fBufferCache->GetBuffer(fChunkSize, &fUncompressBuffer, &newBuffer)
+		if (fBufferPool->GetBuffer(fChunkSize, &fUncompressBuffer, &newBuffer)
 				== NULL) {
 			return B_NO_MEMORY;
 		}
-		CachedBufferPutter uncompressBufferPutter(fBufferCache,
+		PoolBufferPutter uncompressBufferPutter(fBufferPool,
 			&fUncompressBuffer);
 
 		if (newBuffer)
@@ -284,10 +284,10 @@ private:
 				compressedSize);
 		} else {
 			// read to a read buffer and uncompress
-			CachedBuffer* readBuffer = fBufferCache->GetBuffer(fChunkSize);
+			PoolBuffer* readBuffer = fBufferPool->GetBuffer(fChunkSize);
 			if (readBuffer == NULL)
 				return B_NO_MEMORY;
-			CachedBufferPutter readBufferPutter(fBufferCache, readBuffer);
+			PoolBufferPutter readBufferPutter(fBufferPool, readBuffer);
 
 			error = fDataReader->ReadData(offset, readBuffer->Buffer(),
 				compressedSize);
@@ -381,8 +381,8 @@ private:
 	}
 
 private:
-	BBufferCache*	fBufferCache;
+	BBufferPool*	fBufferPool;
-	CachedBuffer*	fUncompressBuffer;
+	PoolBuffer*		fUncompressBuffer;
 	int64			fUncompressedChunk;
 
 	uint64			fOffset;
@@ -400,9 +400,9 @@ private:
 // #pragma mark - BPackageDataReaderFactory
 
 
-BPackageDataReaderFactory::BPackageDataReaderFactory(BBufferCache* bufferCache)
+BPackageDataReaderFactory::BPackageDataReaderFactory(BBufferPool* bufferPool)
 	:
-	fBufferCache(bufferCache)
+	fBufferPool(bufferPool)
 {
 }
 
@@ -416,11 +416,11 @@ BPackageDataReaderFactory::CreatePackageDataReader(BDataReader* dataReader,
 	switch (data.Compression()) {
 		case B_HPKG_COMPRESSION_NONE:
 			reader = new(std::nothrow) UncompressedPackageDataReader(
-				dataReader, fBufferCache);
+				dataReader, fBufferPool);
 			break;
 		case B_HPKG_COMPRESSION_ZLIB:
 			reader = new(std::nothrow) ZlibPackageDataReader(dataReader,
-				fBufferCache);
+				fBufferPool);
 			break;
 		default:
 			return B_BAD_VALUE;

src/system/boot/loader/file_systems/packagefs/Jamfile

@@ -19,13 +19,13 @@ BootStaticLibrary boot_packagefs :
 	packagefs.cpp
 
 	# package kit
-	BlockBufferCacheNoLock.cpp
 
 	# package kit/hpkg
-	BlockBufferCache.cpp
+	BlockBufferPool.cpp
-	BlockBufferCacheImpl.cpp
+	BlockBufferPoolImpl.cpp
-	BufferCache.cpp
+	BlockBufferPoolNoLock.cpp
-	CachedBuffer.cpp
+	BufferPool.cpp
+	PoolBuffer.cpp
 	DataOutput.cpp
 	DataReader.cpp
 	ErrorOutput.cpp

src/system/boot/loader/file_systems/packagefs/packagefs.cpp

@@ -9,7 +9,7 @@
 #include <errno.h>
 #include <unistd.h>
 
-#include <package/BlockBufferCacheNoLock.h>
+#include <package/hpkg/BlockBufferPoolNoLock.h>
 #include <package/hpkg/DataReader.h>
 #include <package/hpkg/ErrorOutput.h>
 #include <package/hpkg/PackageDataReader.h>
@@ -272,7 +272,7 @@ struct FileDataReader {
 private:
 	BFDDataReader		fDataReader;
 	BPackageData		fData;
-	BPackageDataReader*	fPackageDataReader;
+	BAbstractBufferedDataReader* fPackageDataReader;
 };
 
 
@@ -345,7 +345,7 @@ struct PackageVolume : BReferenceable {
 private:
 	ino_t						fNextNodeID;
 	PackageDirectory			fRootDirectory;
-	BBlockBufferCacheNoLock		fBufferCache;
+	BBlockBufferPoolNoLock		fBufferCache;
 	BPackageDataReaderFactory	fDataReaderFactory;
 	int							fFD;
 };