Cleanup:

* PackageWriterImpl no longer accesses members of WriterImplBase 
  directly, but uses getters/setters instead
* package attribute registration has been moved from PackageWriterImpl
  to WriterImplBase, as it will be used in the same manner by the
  RepositoryWriter


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40388 a95241bf-73f2-0310-859d-f6bbb57e9c96

headers/private/package/hpkg/PackageWriterImpl.h

@@ -61,18 +61,6 @@ private:
 									const char* name, size_t nameLength,
 									bool isImplicit);
 
-			void				_RegisterPackageInfo(
-									PackageAttributeList& attributeList,
-									const BPackageInfo& packageInfo);
-			void				_RegisterPackageVersion(
-									PackageAttributeList& attributeList,
-									const BPackageVersion& version);
-			void				_RegisterPackageResolvableExpressionList(
-									PackageAttributeList& attributeList,
-									const BObjectList<
-										BPackageResolvableExpression>& list,
-									uint8 id);
-
 			void				_WriteTOC(hpkg_header& header);
 			int32				_WriteTOCSections(uint64& _attributeTypesSize,
 									uint64& _stringsSize, uint64& _mainSize);
@@ -116,6 +104,9 @@ private:
 			off_t				fHeapOffset;
 			off_t				fHeapEnd;
 
+			void*				fDataBuffer;
+			const size_t		fDataBufferSize;
+
 			Entry*				fRootEntry;
 
 			Attribute*			fRootAttribute;

headers/private/package/hpkg/RepositoryWriterImpl.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2011, Oliver Tappe <[email protected]>
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _PACKAGE__HPKG__PRIVATE__REPOSITORY_WRITER_IMPL_H_
+#define _PACKAGE__HPKG__PRIVATE__REPOSITORY_WRITER_IMPL_H_
+
+
+#include <util/DoublyLinkedList.h>
+#include <util/OpenHashTable.h>
+
+#include <package/PackageInfo.h>
+#include <package/hpkg/Strings.h>
+#include <package/hpkg/WriterImplBase.h>
+
+
+namespace BPackageKit {
+
+namespace BHPKG {
+
+
+class BDataReader;
+class BErrorOutput;
+
+
+namespace BPrivate {
+
+
+struct hpkg_header;
+
+class RepositoryWriterImpl : public WriterImplBase {
+public:
+								RepositoryWriterImpl(
+									BRepositoryWriterListener* listener);
+								~RepositoryWriterImpl();
+
+			status_t			Init(const char* fileName);
+			status_t			AddPackage(const BPackageInfo& packageInfo);
+			status_t			Finish();
+
+private:
+			status_t			_Init(const char* fileName);
+			status_t			_AddPackage(const BPackageInfo& packageInfo);
+			status_t			_Finish();
+
+private:
+			BRepositoryWriterListener*	fListener;
+
+};
+
+
+}	// namespace BPrivate
+
+}	// namespace BHPKG
+
+}	// namespace BPackageKit
+
+
+#endif	// _PACKAGE__HPKG__PRIVATE__REPOSITORY_WRITER_IMPL_H_

headers/private/package/hpkg/WriterImplBase.h

@@ -93,9 +93,9 @@ protected:
 			};
 
 
-			struct DataWriter {
-				DataWriter();
-				virtual ~DataWriter();
+			struct AbstractDataWriter {
+				AbstractDataWriter();
+				virtual ~AbstractDataWriter();
 
 				uint64 BytesWritten() const;
 
@@ -109,7 +109,7 @@ protected:
 			};
 
 
-			struct FDDataWriter : DataWriter {
+			struct FDDataWriter : AbstractDataWriter {
 				FDDataWriter(int fd, off_t offset, BErrorOutput* errorOutput);
 
 				virtual status_t WriteDataNoThrow(const void* buffer,
@@ -124,8 +124,8 @@ protected:
 			};
 
 
-			struct ZlibDataWriter : DataWriter, private BDataOutput {
-				ZlibDataWriter(DataWriter* dataWriter);
+			struct ZlibDataWriter : AbstractDataWriter, private BDataOutput {
+				ZlibDataWriter(AbstractDataWriter* dataWriter);
 
 				void Init();
 
@@ -139,8 +139,8 @@ protected:
 				virtual status_t WriteData(const void* buffer, size_t size);
 
 			private:
-				DataWriter*		fDataWriter;
-				ZlibCompressor	fCompressor;
+				AbstractDataWriter*	fDataWriter;
+				ZlibCompressor		fCompressor;
 			};
 
 
@@ -149,11 +149,24 @@ protected:
 protected:
 			status_t			Init(const char* fileName, const char* type);
 
+			void				RegisterPackageInfo(
+									PackageAttributeList& attributeList,
+									const BPackageInfo& packageInfo);
+			void				RegisterPackageVersion(
+									PackageAttributeList& attributeList,
+									const BPackageVersion& version);
+			void				RegisterPackageResolvableExpressionList(
+									PackageAttributeList& attributeList,
+									const BObjectList<
+										BPackageResolvableExpression>& list,
+									uint8 id);
+
 			int32				WriteCachedStrings(const StringCache& cache,
 									uint32 minUsageCount);
 
-			void				WritePackageAttributes(
-									const PackageAttributeList& attributes);
+			int32				WritePackageAttributes(
+									const PackageAttributeList& attributes,
+									uint32& _stringsLengthUncompressed);
 			void				WritePackageVersion(
 									const BPackageVersion& version);
 			void				WritePackageResolvableExpressionList(
@@ -172,30 +185,40 @@ protected:
 			void				WriteBuffer(const void* buffer, size_t size,
 									off_t offset);
 
-protected:
+			int					FD() const;
+			AbstractDataWriter*	DataWriter() const;
+			const PackageAttributeList&	PackageAttributes() const;
+			PackageAttributeList&	PackageAttributes();
+
+			void				SetDataWriter(AbstractDataWriter* dataWriter);
+			void				SetFinished(bool finished);
+
+private:
+			void				_WritePackageAttributes(
+									const PackageAttributeList& attributes);
+
+private:
 			BErrorOutput*		fErrorOutput;
 			const char*			fFileName;
 			int					fFD;
 			bool				fFinished;
-			void*				fDataBuffer;
-			const size_t		fDataBufferSize;
 
-			DataWriter*			fDataWriter;
+			AbstractDataWriter*	fDataWriter;
 
 			StringCache			fPackageStringCache;
-			DoublyLinkedList<PackageAttribute>	fPackageAttributes;
+			PackageAttributeList	fPackageAttributes;
 };
 
 
 inline uint64
-WriterImplBase::DataWriter::BytesWritten() const
+WriterImplBase::AbstractDataWriter::BytesWritten() const
 {
 	return fBytesWritten;
 }
 
 
 inline void
-WriterImplBase::DataWriter::WriteDataThrows(const void* buffer, size_t size)
+WriterImplBase::AbstractDataWriter::WriteDataThrows(const void* buffer, size_t size)
 {
 	status_t error = WriteDataNoThrow(buffer, size);
 	if (error != B_OK)
@@ -224,6 +247,48 @@ WriterImplBase::WriteString(const char* string)
 }
 
 
+inline int
+WriterImplBase::FD() const
+{
+	return fFD;
+}
+
+
+inline WriterImplBase::AbstractDataWriter*
+WriterImplBase::DataWriter() const
+{
+	return fDataWriter;
+}
+
+
+inline void
+WriterImplBase::SetDataWriter(AbstractDataWriter* dataWriter)
+{
+	fDataWriter = dataWriter;
+}
+
+
+inline const WriterImplBase::PackageAttributeList&
+WriterImplBase::PackageAttributes() const
+{
+	return fPackageAttributes;
+}
+
+
+inline WriterImplBase::PackageAttributeList&
+WriterImplBase::PackageAttributes()
+{
+	return fPackageAttributes;
+}
+
+
+inline void
+WriterImplBase::SetFinished(bool finished)
+{
+	fFinished = finished;
+}
+
+
 }	// namespace BPrivate
 
 }	// namespace BHPKG