[haiku-commits] r40301 - in haiku/trunk: headers/os/package headers/private headers/private/package headers/private/package/hpkg src/add-ons/kernel/file_systems/packagefs ...

  • From: zooey@xxxxxxxxxxxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Fri, 28 Jan 2011 00:17:15 +0100 (CET)

Author: zooey
Date: 2011-01-28 00:17:03 +0100 (Fri, 28 Jan 2011)
New Revision: 40301
Changeset: http://dev.haiku-os.org/changeset/40301

Added:
   haiku/trunk/headers/os/package/PackageInfo.h
   haiku/trunk/headers/private/package/hpkg/
   haiku/trunk/headers/private/package/hpkg/BlockBufferCache.h
   haiku/trunk/headers/private/package/hpkg/BufferCache.h
   haiku/trunk/headers/private/package/hpkg/DataOutput.h
   haiku/trunk/headers/private/package/hpkg/DataReader.h
   haiku/trunk/headers/private/package/hpkg/ErrorOutput.h
   haiku/trunk/headers/private/package/hpkg/FDCloser.h
   haiku/trunk/headers/private/package/hpkg/PackageAttributeValue.h
   haiku/trunk/headers/private/package/hpkg/PackageData.h
   haiku/trunk/headers/private/package/hpkg/PackageDataReader.h
   haiku/trunk/headers/private/package/hpkg/PackageEntry.h
   haiku/trunk/headers/private/package/hpkg/PackageEntryAttribute.h
   haiku/trunk/headers/private/package/hpkg/PackageReader.h
   haiku/trunk/headers/private/package/hpkg/PackageWriter.h
   haiku/trunk/headers/private/package/hpkg/Stacker.h
   haiku/trunk/headers/private/package/hpkg/Strings.h
   haiku/trunk/headers/private/package/hpkg/ZlibCompressionBase.h
   haiku/trunk/headers/private/package/hpkg/ZlibCompressor.h
   haiku/trunk/headers/private/package/hpkg/ZlibDecompressor.h
   haiku/trunk/headers/private/package/hpkg/haiku_package.h
   haiku/trunk/src/bin/package/StandardErrorOutput.cpp
   haiku/trunk/src/bin/package/StandardErrorOutput.h
   haiku/trunk/src/kits/package/PackageInfo.cpp
   haiku/trunk/src/kits/package/hpkg/
   haiku/trunk/src/kits/package/hpkg/BlockBufferCache.cpp
   haiku/trunk/src/kits/package/hpkg/BufferCache.cpp
   haiku/trunk/src/kits/package/hpkg/DataOutput.cpp
   haiku/trunk/src/kits/package/hpkg/DataReader.cpp
   haiku/trunk/src/kits/package/hpkg/ErrorOutput.cpp
   haiku/trunk/src/kits/package/hpkg/PackageData.cpp
   haiku/trunk/src/kits/package/hpkg/PackageDataReader.cpp
   haiku/trunk/src/kits/package/hpkg/PackageEntry.cpp
   haiku/trunk/src/kits/package/hpkg/PackageEntryAttribute.cpp
   haiku/trunk/src/kits/package/hpkg/PackageReader.cpp
   haiku/trunk/src/kits/package/hpkg/PackageWriter.cpp
   haiku/trunk/src/kits/package/hpkg/Strings.cpp
   haiku/trunk/src/kits/package/hpkg/ZlibCompressionBase.cpp
   haiku/trunk/src/kits/package/hpkg/ZlibCompressor.cpp
   haiku/trunk/src/kits/package/hpkg/ZlibDecompressor.cpp
Removed:
   haiku/trunk/headers/private/haiku_package/
   haiku/trunk/headers/private/package/hpkg/haiku_package.h
   haiku/trunk/src/bin/package/BlockBufferCache.cpp
   haiku/trunk/src/bin/package/BlockBufferCache.h
   haiku/trunk/src/bin/package/BufferCache.cpp
   haiku/trunk/src/bin/package/BufferCache.h
   haiku/trunk/src/bin/package/DataOutput.cpp
   haiku/trunk/src/bin/package/DataOutput.h
   haiku/trunk/src/bin/package/DataReader.cpp
   haiku/trunk/src/bin/package/DataReader.h
   haiku/trunk/src/bin/package/ErrorOutput.cpp
   haiku/trunk/src/bin/package/ErrorOutput.h
   haiku/trunk/src/bin/package/FDCloser.h
   haiku/trunk/src/bin/package/PackageAttributeValue.h
   haiku/trunk/src/bin/package/PackageData.cpp
   haiku/trunk/src/bin/package/PackageData.h
   haiku/trunk/src/bin/package/PackageDataReader.cpp
   haiku/trunk/src/bin/package/PackageDataReader.h
   haiku/trunk/src/bin/package/PackageEntry.cpp
   haiku/trunk/src/bin/package/PackageEntry.h
   haiku/trunk/src/bin/package/PackageEntryAttribute.cpp
   haiku/trunk/src/bin/package/PackageEntryAttribute.h
   haiku/trunk/src/bin/package/PackageReader.cpp
   haiku/trunk/src/bin/package/PackageReader.h
   haiku/trunk/src/bin/package/PackageWriter.cpp
   haiku/trunk/src/bin/package/PackageWriter.h
   haiku/trunk/src/bin/package/Stacker.h
   haiku/trunk/src/bin/package/StandardErrorOutput.cpp
   haiku/trunk/src/bin/package/StandardErrorOutput.h
   haiku/trunk/src/bin/package/Strings.cpp
   haiku/trunk/src/bin/package/Strings.h
   haiku/trunk/src/bin/package/compression/
Modified:
   haiku/trunk/headers/os/package/Attributes.h
   haiku/trunk/headers/os/package/PackageRoster.h
   
haiku/trunk/src/add-ons/kernel/file_systems/packagefs/BlockBufferCacheKernel.h
   haiku/trunk/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.cpp
   haiku/trunk/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.h
   haiku/trunk/src/add-ons/kernel/file_systems/packagefs/Jamfile
   haiku/trunk/src/add-ons/kernel/file_systems/packagefs/PackageFile.cpp
   haiku/trunk/src/add-ons/kernel/file_systems/packagefs/PackageFile.h
   haiku/trunk/src/add-ons/kernel/file_systems/packagefs/PackageNodeAttribute.h
   haiku/trunk/src/add-ons/kernel/file_systems/packagefs/Volume.cpp
   haiku/trunk/src/bin/package/Jamfile
   haiku/trunk/src/bin/package/command_create.cpp
   haiku/trunk/src/bin/package/command_dump.cpp
   haiku/trunk/src/bin/package/command_extract.cpp
   haiku/trunk/src/bin/package/command_list.cpp
   haiku/trunk/src/bin/package/package.cpp
   haiku/trunk/src/kits/package/Attributes.cpp
   haiku/trunk/src/kits/package/Jamfile
   haiku/trunk/src/kits/package/RepositoryConfig.cpp
Log:
More work on package kit:
* added class BPackageInfo, which contains packaging attributes of
  a package (the values relevant for package management) 
* implemented parser (mostly) for reading a BPackageInfo from a config
  file (.PackageInfo) in order to pass them on to the PackageWriter 
  when creating a package
* pulled hpkg-related stuff from bin/package into the package kit
* adjusted packagefs-Volume to skip .PackageInfo files when populating
  the mountpoint, as those files shouldn't appear as part of an
  activated package


Modified: haiku/trunk/headers/os/package/Attributes.h
===================================================================
--- haiku/trunk/headers/os/package/Attributes.h 2011-01-27 22:30:25 UTC (rev 
40300)
+++ haiku/trunk/headers/os/package/Attributes.h 2011-01-27 23:17:03 UTC (rev 
40301)
@@ -15,8 +15,9 @@
 extern const char* kPackageVersionAttribute;
 
 // attributes kept local to packages
-extern const char* kPackageCopyrightAttribute;
-extern const char* kPackageLicenseAttribute;
+extern const char* kPackageCopyrightsAttribute;
+extern const char* kPackageLicensesAttribute;
+extern const char* kPackagePackagerAttribute;
 extern const char* kPackageProvidesAttribute;
 extern const char* kPackageRequiresAttribute;
 

Added: haiku/trunk/headers/os/package/PackageInfo.h
===================================================================
--- haiku/trunk/headers/os/package/PackageInfo.h                                
(rev 0)
+++ haiku/trunk/headers/os/package/PackageInfo.h        2011-01-27 23:17:03 UTC 
(rev 40301)
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2011, Oliver Tappe <zooey@xxxxxxxxxxxxxxx>
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _PACKAGE__PACKAGE_INFO_H_
+#define _PACKAGE__PACKAGE_INFO_H_
+
+
+#include <ObjectList.h>
+#include <String.h>
+
+
+class BEntry;
+
+
+namespace BPackageKit {
+
+
+enum BPackageInfoIndex {
+       B_PACKAGE_INFO_NAME = 0,
+       B_PACKAGE_INFO_SUMMARY,                 // single line, 72 chars max
+       B_PACKAGE_INFO_DESCRIPTION,             // multiple lines possible
+       B_PACKAGE_INFO_VENDOR,                  // e.g. "Haiku Project"
+       B_PACKAGE_INFO_PACKAGER,                // e-mail address preferred
+       B_PACKAGE_INFO_ARCHITECTURE,
+       B_PACKAGE_INFO_VERSION,
+       B_PACKAGE_INFO_COPYRIGHTS,              // list
+       B_PACKAGE_INFO_LICENSES,                // list
+       B_PACKAGE_INFO_PROVIDES,                // list
+       B_PACKAGE_INFO_REQUIRES,                // list
+       //
+       B_PACKAGE_INFO_ENUM_COUNT,
+};
+
+
+enum BPackageArchitecture {
+       B_PACKAGE_ARCHITECTURE_NONE = 0,
+       B_PACKAGE_ARCHITECTURE_X86,
+       B_PACKAGE_ARCHITECTURE_X86_GCC2,
+       //
+       B_PACKAGE_ARCHITECTURE_ENUM_COUNT,
+};
+
+
+class BPackageVersion {
+public:
+                       void                            MakeEmpty() {}
+};
+
+
+class BPackageProvision {
+public:
+                       int                                     Compare(const 
BPackageProvision& other) const
+                       {
+                               return fX.Compare(other.fX);
+                       }
+private:
+                       BString fX;
+};
+
+
+class BPackageRequirement {
+public:
+                       int                                     Compare(const 
BPackageRequirement& other) const
+                       {
+                               return fX.Compare(other.fX);
+                       }
+private:
+                       BString fX;
+};
+
+
+/*
+ * Keeps a list of package info elements (e.g. name, version, vendor, ...) 
which
+ * will be converted to package attributes when creating a package. Usually,
+ * these elements have been parsed from a ".PackageInfo"-file.
+ * Alternatively, the package reader populates a BPackageInfo object by
+ * collecting package attributes from an existing package.
+ */
+class BPackageInfo {
+public:
+                       struct ParseErrorListener {
+                               virtual ~ParseErrorListener();
+                               virtual void OnError(const BString& msg, int 
line, int col) = 0;
+                       };
+
+public:
+                                                               BPackageInfo();
+                                                               ~BPackageInfo();
+
+                       status_t                        ReadFromConfigFile(
+                                                                       const 
BEntry& packageInfoEntry,
+                                                                       
ParseErrorListener* listener = NULL);
+                       status_t                        ReadFromConfigString(
+                                                                       const 
BString& packageInfoString,
+                                                                       
ParseErrorListener* listener = NULL);
+
+                       status_t                        InitCheck() const;
+
+                       const BString&          Name() const;
+                       const BString&          Summary() const;
+                       const BString&          Description() const;
+                       const BString&          Vendor() const;
+                       const BString&          Packager() const;
+
+                       BPackageArchitecture    Architecture() const;
+
+                       const BPackageVersion&  Version() const;
+
+                       const BObjectList<BString>&     Copyrights() const;
+                       const BObjectList<BString>&     Licenses() const;
+
+                       const BObjectList<BPackageRequirement>& Requirements() 
const;
+                       const BObjectList<BPackageProvision>&   Provisions() 
const;
+
+                       void                            SetName(const BString& 
name);
+                       void                            SetSummary(const 
BString& summary);
+                       void                            SetDescription(const 
BString& description);
+                       void                            SetVendor(const 
BString& vendor);
+                       void                            SetPackager(const 
BString& packager);
+
+                       void                            SetArchitecture(
+                                                                       
BPackageArchitecture architecture);
+
+                       void                            SetVersion(const 
BPackageVersion& version);
+
+                       void                            ClearCopyrights();
+                       status_t                        AddCopyright(const 
BString& copyright);
+                       status_t                        RemoveCopyright(const 
BString& copyright);
+
+                       void                            ClearLicenses();
+                       status_t                        AddLicense(const 
BString& license);
+                       status_t                        RemoveLicense(const 
BString& license);
+
+                       void                            ClearProvisions();
+                       status_t                        AddProvision(
+                                                                       const 
BPackageProvision& provision);
+                       status_t                        RemoveProvision(
+                                                                       const 
BPackageProvision& provision);
+
+                       void                            ClearRequirements();
+                       status_t                        AddRequirement(
+                                                                       const 
BPackageRequirement& requirement);
+                       status_t                        RemoveRequirement(
+                                                                       const 
BPackageRequirement& requirement);
+
+                       void                            MakeEmpty();
+
+public:
+       static  status_t                        GetElementName(
+                                                                       
BPackageInfoIndex index,
+                                                                       const 
char** name);
+
+private:
+                       class Parser;
+       friend  class Parser;
+
+       static  const char*                     kElementNames[];
+       static  const char*                     kArchitectureNames[];
+
+private:
+                       BString                         fName;
+                       BString                         fSummary;
+                       BString                         fDescription;
+                       BString                         fVendor;
+                       BString                         fPackager;
+
+                       BPackageArchitecture    fArchitecture;
+
+                       BPackageVersion         fVersion;
+
+                       BObjectList<BString>    fCopyrights;
+                       BObjectList<BString>    fLicenses;
+
+                       BObjectList<BPackageProvision>  fProvisions;
+                       BObjectList<BPackageRequirement>        fRequirements;
+};
+
+
+}      // namespace BPackageKit
+
+
+#endif // _PACKAGE__PACKAGE_INFO_H_

Modified: haiku/trunk/headers/os/package/PackageRoster.h
===================================================================
--- haiku/trunk/headers/os/package/PackageRoster.h      2011-01-27 22:30:25 UTC 
(rev 40300)
+++ haiku/trunk/headers/os/package/PackageRoster.h      2011-01-27 23:17:03 UTC 
(rev 40301)
@@ -2,8 +2,8 @@
  * Copyright 2011, Haiku, Inc.
  * Distributed under the terms of the MIT License.
  */
-#ifndef _PACKAGE__ROSTER_H_
-#define _PACKAGE__ROSTER_H_
+#ifndef _PACKAGE__PACKAGE_ROSTER_H_
+#define _PACKAGE__PACKAGE_ROSTER_H_
 
 
 #include <Entry.h>
@@ -68,4 +68,4 @@
 }      // namespace BPackageKit
 
 
-#endif // _PACKAGE__ROSTER_H_
+#endif // _PACKAGE__PACKAGE_ROSTER_H_

Copied: haiku/trunk/headers/private/package/hpkg/BlockBufferCache.h (from rev 
40260, haiku/trunk/src/bin/package/BlockBufferCache.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/BlockBufferCache.h                 
        (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/BlockBufferCache.h 2011-01-27 
23:17:03 UTC (rev 40301)
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_
+#define _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_
+
+
+#include <package/hpkg/BufferCache.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+class BlockBufferCache : public BufferCache {
+public:
+                                                               
BlockBufferCache(size_t blockSize,
+                                                                       uint32 
maxCachedBlocks);
+       virtual                                         ~BlockBufferCache();
+
+       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);
+
+       virtual bool                            Lock() = 0;
+       virtual void                            Unlock() = 0;
+
+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;
+};
+
+
+class BlockBufferCacheNoLock : public BlockBufferCache {
+public:
+                                                               
BlockBufferCacheNoLock(size_t blockSize,
+                                                                       uint32 
maxCachedBlocks);
+       virtual                                         
~BlockBufferCacheNoLock();
+
+       virtual bool                            Lock();
+       virtual void                            Unlock();
+};
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_

Copied: haiku/trunk/headers/private/package/hpkg/BufferCache.h (from rev 40260, 
haiku/trunk/src/bin/package/BufferCache.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/BufferCache.h                      
        (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/BufferCache.h      2011-01-27 
23:17:03 UTC (rev 40301)
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _PACKAGE__HPKG__BUFFER_CACHE_H_
+#define _PACKAGE__HPKG__BUFFER_CACHE_H_
+
+
+#include <stddef.h>
+
+#include <util/DoublyLinkedList.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+class CachedBuffer : public DoublyLinkedListLinkImpl<CachedBuffer> {
+public:
+                                                               
CachedBuffer(size_t size);
+                                                               ~CachedBuffer();
+
+                       void*                           Buffer() const  { 
return fBuffer; }
+                       size_t                          Size() const    { 
return fSize; }
+
+
+                       // implementation private
+                       CachedBuffer**          Owner() const   { return 
fOwner; }
+                       void                            SetOwner(CachedBuffer** 
owner)
+                                                                       { 
fOwner = owner; }
+
+                       void                            SetCached(bool cached)  
{ fCached = cached; }
+                       bool                            IsCached() const        
        { return fCached; }
+
+private:
+                       CachedBuffer**          fOwner;
+                       void*                           fBuffer;
+                       size_t                          fSize;
+                       bool                            fCached;
+};
+
+
+class BufferCache {
+public:
+       virtual                                         ~BufferCache();
+
+       virtual CachedBuffer*           GetBuffer(size_t size,
+                                                                       
CachedBuffer** owner = NULL,
+                                                                       bool* 
_newBuffer = NULL) = 0;
+       virtual void                            
PutBufferAndCache(CachedBuffer** owner) = 0;
+                                                                       // 
caller is buffer owner and wants the
+                                                                       // 
buffer cached, if possible
+       virtual void                            PutBuffer(CachedBuffer** owner) 
= 0;
+                                                                       // puts 
the buffer for good, owner might
+                                                                       // have 
called PutBufferAndCache() before
+                                                                       // and 
might not own a buffer anymore
+};
+
+
+class CachedBufferPutter {
+public:
+       CachedBufferPutter(BufferCache* cache, CachedBuffer** owner)
+               :
+               fCache(cache),
+               fOwner(owner),
+               fBuffer(NULL)
+       {
+       }
+
+       CachedBufferPutter(BufferCache* cache, CachedBuffer* buffer)
+               :
+               fCache(cache),
+               fOwner(NULL),
+               fBuffer(buffer)
+       {
+       }
+
+       ~CachedBufferPutter()
+       {
+               if (fCache != NULL) {
+                       if (fOwner != NULL)
+                               fCache->PutBufferAndCache(fOwner);
+                       else if (fBuffer != NULL)
+                               fCache->PutBuffer(&fBuffer);
+               }
+       }
+
+private:
+       BufferCache*    fCache;
+       CachedBuffer**  fOwner;
+       CachedBuffer*   fBuffer;
+};
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // _PACKAGE__HPKG__BUFFER_CACHE_H_

Copied: haiku/trunk/headers/private/package/hpkg/DataOutput.h (from rev 40260, 
haiku/trunk/src/bin/package/DataOutput.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/DataOutput.h                       
        (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/DataOutput.h       2011-01-27 
23:17:03 UTC (rev 40301)
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef DATA_OUTPUT_H
+#define DATA_OUTPUT_H
+
+
+#include <SupportDefs.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+class DataOutput {
+public:
+       virtual                                         ~DataOutput();
+
+       virtual status_t                        WriteData(const void* buffer, 
size_t size) = 0;
+};
+
+
+class BufferDataOutput : public DataOutput {
+public:
+                                                               
BufferDataOutput(void* buffer, size_t size);
+
+                       size_t                          BytesWritten() const { 
return fBytesWritten; }
+
+       virtual status_t                        WriteData(const void* buffer, 
size_t size);
+
+private:
+                       void*                           fBuffer;
+                       size_t                          fSize;
+                       size_t                          fBytesWritten;
+};
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // DATA_OUTPUT_H

Copied: haiku/trunk/headers/private/package/hpkg/DataReader.h (from rev 40260, 
haiku/trunk/src/bin/package/DataReader.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/DataReader.h                       
        (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/DataReader.h       2011-01-27 
23:17:03 UTC (rev 40301)
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef DATA_READER_H
+#define DATA_READER_H
+
+
+#include <SupportDefs.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+class DataReader {
+public:
+       virtual                                         ~DataReader();
+
+       virtual status_t                        ReadData(off_t offset, void* 
buffer,
+                                                                       size_t 
size) = 0;
+};
+
+
+class FDDataReader : public DataReader {
+public:
+                                                               
FDDataReader(int fd);
+
+       virtual status_t                        ReadData(off_t offset, void* 
buffer,
+                                                                       size_t 
size);
+
+private:
+                       int                                     fFD;
+};
+
+
+class AttributeDataReader : public DataReader {
+public:
+                                                               
AttributeDataReader(int fd,
+                                                                       const 
char* attribute, uint32 type);
+
+       virtual status_t                        ReadData(off_t offset, void* 
buffer,
+                                                                       size_t 
size);
+
+private:
+                       int                                     fFD;
+                       uint32                          fType;
+                       const char*                     fAttribute;
+};
+
+
+class BufferDataReader : public DataReader {
+public:
+                                                               
BufferDataReader(const void* data, size_t size);
+
+       virtual status_t                        ReadData(off_t offset, void* 
buffer,
+                                                                       size_t 
size);
+
+private:
+                       const void*                     fData;
+                       size_t                          fSize;
+};
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // DATA_READER_H

Copied: haiku/trunk/headers/private/package/hpkg/ErrorOutput.h (from rev 40260, 
haiku/trunk/src/bin/package/ErrorOutput.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/ErrorOutput.h                      
        (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/ErrorOutput.h      2011-01-27 
23:17:03 UTC (rev 40301)
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef ERROR_OUTPUT_H
+#define ERROR_OUTPUT_H
+
+
+#include <stdarg.h>
+
+#include <SupportDefs.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+class ErrorOutput {
+public:
+       virtual                                         ~ErrorOutput();
+
+       virtual void                            PrintErrorVarArgs(const char* 
format,
+                                                                       va_list 
args) = 0;
+                       void                            PrintError(const char* 
format, ...);
+};
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // ERROR_OUTPUT_H

Copied: haiku/trunk/headers/private/package/hpkg/FDCloser.h (from rev 40260, 
haiku/trunk/src/bin/package/FDCloser.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/FDCloser.h                         
(rev 0)
+++ haiku/trunk/headers/private/package/hpkg/FDCloser.h 2011-01-27 23:17:03 UTC 
(rev 40301)
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef FD_CLOSER_H
+#define FD_CLOSER_H
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+struct FDCloser {
+       FDCloser(int fd)
+               :
+               fFD(fd)
+       {
+       }
+
+       ~FDCloser()
+       {
+               if (fFD >= 0)
+                       close(fFD);
+       }
+
+private:
+       int     fFD;
+};
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // FD_CLOSER_H

Copied: haiku/trunk/headers/private/package/hpkg/PackageAttributeValue.h (from 
rev 40260, haiku/trunk/src/bin/package/PackageAttributeValue.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/PackageAttributeValue.h            
                (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/PackageAttributeValue.h    
2011-01-27 23:17:03 UTC (rev 40301)
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef PACKAGE_ATTRIBUTE_VALUE_H
+#define PACKAGE_ATTRIBUTE_VALUE_H
+
+
+#include <string.h>
+
+#include <package/hpkg/haiku_package.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+struct PackageAttributeValue {
+                       union {
+                               int64                   signedInt;
+                               uint64                  unsignedInt;
+                               const char*             string;
+                               struct {
+                                       uint64          size;
+                                       union {
+                                               uint64  offset;
+                                               uint8   
raw[B_HPKG_MAX_INLINE_DATA_SIZE];
+                                       };
+                               } data;
+                       };
+                       uint8                           type;
+                       uint8                           encoding;
+
+public:
+       inline                                          PackageAttributeValue();
+
+       inline  void                            SetTo(int8 value);
+       inline  void                            SetTo(uint8 value);
+       inline  void                            SetTo(int16 value);
+       inline  void                            SetTo(uint16 value);
+       inline  void                            SetTo(int32 value);
+       inline  void                            SetTo(uint32 value);
+       inline  void                            SetTo(int64 value);
+       inline  void                            SetTo(uint64 value);
+       inline  void                            SetTo(const char* value);
+       inline  void                            SetToData(uint64 size, uint64 
offset);
+       inline  void                            SetToData(uint64 size, const 
void* rawData);
+};
+
+
+PackageAttributeValue::PackageAttributeValue()
+       :
+       type(B_HPKG_ATTRIBUTE_TYPE_INVALID)
+{
+}
+
+
+void
+PackageAttributeValue::SetTo(int8 value)
+{
+       signedInt = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_INT;
+}
+
+
+void
+PackageAttributeValue::SetTo(uint8 value)
+{
+       unsignedInt = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_UINT;
+}
+
+
+void
+PackageAttributeValue::SetTo(int16 value)
+{
+       signedInt = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_INT;
+}
+
+
+void
+PackageAttributeValue::SetTo(uint16 value)
+{
+       unsignedInt = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_UINT;
+}
+
+
+void
+PackageAttributeValue::SetTo(int32 value)
+{
+       signedInt = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_INT;
+}
+
+
+void
+PackageAttributeValue::SetTo(uint32 value)
+{
+       unsignedInt = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_UINT;
+}
+
+
+void
+PackageAttributeValue::SetTo(int64 value)
+{
+       signedInt = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_INT;
+}
+
+
+void
+PackageAttributeValue::SetTo(uint64 value)
+{
+       unsignedInt = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_UINT;
+}
+
+
+void
+PackageAttributeValue::SetTo(const char* value)
+{
+       string = value;
+       type = B_HPKG_ATTRIBUTE_TYPE_STRING;
+}
+
+
+void
+PackageAttributeValue::SetToData(uint64 size, uint64 offset)
+{
+       data.size = size;
+       data.offset = offset;
+       type = B_HPKG_ATTRIBUTE_TYPE_RAW;
+       encoding = B_HPKG_ATTRIBUTE_ENCODING_RAW_HEAP;
+}
+
+
+void
+PackageAttributeValue::SetToData(uint64 size, const void* rawData)
+{
+       data.size = size;
+       if (size > 0)
+               memcpy(data.raw, rawData, size);
+       type = B_HPKG_ATTRIBUTE_TYPE_RAW;
+       encoding = B_HPKG_ATTRIBUTE_ENCODING_RAW_INLINE;
+}
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // PACKAGE_ATTRIBUTE_VALUE_H

Copied: haiku/trunk/headers/private/package/hpkg/PackageData.h (from rev 40260, 
haiku/trunk/src/bin/package/PackageData.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/PackageData.h                      
        (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/PackageData.h      2011-01-27 
23:17:03 UTC (rev 40301)
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef PACKAGE_DATA_H
+#define PACKAGE_DATA_H
+
+
+#include <package/hpkg/haiku_package.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+class PackageData {
+public:
+                                                               PackageData();
+
+                       uint64                          CompressedSize() const
+                                                                       { 
return fCompressedSize; }
+                       uint64                          UncompressedSize() const
+                                                                       { 
return fUncompressedSize; }
+                       uint64                          Offset() const
+                                                                       { 
return fEncodedInline ? 0 : fOffset; }
+                       uint32                          Compression() const     
        { return fCompression; }
+                       uint32                          ChunkSize() const       
        { return fChunkSize; }
+
+                       bool                            IsEncodedInline() const
+                                                                       { 
return fEncodedInline; }
+                       const uint8*            InlineData() const              
{ return fInlineData; }
+
+                       void                            SetData(uint64 size, 
uint64 offset);
+                       void                            SetData(uint8 size, 
const void* data);
+
+                       void                            SetCompression(uint32 
compression)
+                                                                       { 
fCompression = compression; }
+                       void                            
SetUncompressedSize(uint64 size)
+                                                                       { 
fUncompressedSize = size; }
+                       void                            SetChunkSize(uint32 
size)
+                                                                       { 
fChunkSize = size; }
+
+private:
+                       uint64                          fCompressedSize;
+                       uint64                          fUncompressedSize;
+                       union {
+                               uint64                  fOffset;
+                               uint8                   
fInlineData[B_HPKG_MAX_INLINE_DATA_SIZE];
+                       };
+                       uint32                          fChunkSize;
+                       uint32                          fCompression;
+                       bool                            fEncodedInline;
+};
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // PACKAGE_DATA_H

Copied: haiku/trunk/headers/private/package/hpkg/PackageDataReader.h (from rev 
40260, haiku/trunk/src/bin/package/PackageDataReader.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/PackageDataReader.h                
                (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/PackageDataReader.h        
2011-01-27 23:17:03 UTC (rev 40301)
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef PACKAGE_DATA_READER_H
+#define PACKAGE_DATA_READER_H
+
+
+#include <package/hpkg/DataReader.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+class BufferCache;
+class DataOutput;
+class PackageData;
+
+
+class PackageDataReader : public DataReader {
+public:
+                                                               
PackageDataReader(DataReader* dataReader);
+       virtual                                         ~PackageDataReader();
+
+       virtual status_t                        Init(const PackageData& data) = 
0;
+
+       virtual status_t                        ReadData(off_t offset, void* 
buffer,
+                                                                       size_t 
size);
+       virtual status_t                        ReadDataToOutput(off_t offset, 
size_t size,
+                                                                       
DataOutput* output) = 0;
+
+       virtual uint64                          Size() const = 0;
+       virtual size_t                          BlockSize() const = 0;
+
+protected:
+                       DataReader*                     fDataReader;
+};
+
+
+class PackageDataReaderFactory {
+public:
+                                                               
PackageDataReaderFactory(
+                                                                       
BufferCache* bufferCache);
+
+                       status_t                        
CreatePackageDataReader(DataReader* dataReader,
+                                                                       const 
PackageData& data,
+                                                                       
PackageDataReader*& _reader);
+
+private:
+                       BufferCache*            fBufferCache;
+};
+
+
+}      // namespace BPrivate
+
+}      // namespace BHaikuPackage
+
+}      // namespace BPackageKit
+
+
+#endif // PACKAGE_DATA_READER_H

Copied: haiku/trunk/headers/private/package/hpkg/PackageEntry.h (from rev 
40260, haiku/trunk/src/bin/package/PackageEntry.h)
===================================================================
--- haiku/trunk/headers/private/package/hpkg/PackageEntry.h                     
        (rev 0)
+++ haiku/trunk/headers/private/package/hpkg/PackageEntry.h     2011-01-27 
23:17:03 UTC (rev 40301)
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef PACKAGE_ENTRY_H
+#define PACKAGE_ENTRY_H
+
+
+#include <sys/stat.h>
+
+#include <package/hpkg/PackageData.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
+class PackageEntry {
+public:
+                                                               
PackageEntry(PackageEntry* parent,
+                                                                       const 
char* name);
+
+                       const PackageEntry*     Parent() const          { 
return fParent; }
+                       const char*                     Name() const            
{ return fName; }
+                       void*                           UserToken() const       
{ return fUserToken; }
+
+                       mode_t                          Mode() const            
{ return fMode; }
+
+                       const timespec&         AccessTime() const
+                                                                       { 
return fAccessTime; }
+                       const timespec&         ModifiedTime() const
+                                                                       { 
return fModifiedTime; }
+                       const timespec&         CreationTime() const
+                                                                       { 
return fCreationTime; }
+
+                       PackageData&            Data()  { return fData; }
+
+                       const char*                     SymlinkPath() const     
{ return fSymlinkPath; }
+

[... truncated: 6932 lines follow ...]

Other related posts: