abscompression.hpp

Absolute Database 5.12 src. Absolute Database lets you forget the Borland Database Engine (BDE). Th

// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Abscompression.pas' rev: 10.00

#ifndef AbscompressionHPP
#define AbscompressionHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit
#include <Absmemory.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit
#include <Absexcept.hpp>	// Pascal unit
#include <Abszlib.hpp>	// Pascal unit
#include <Absbzip2.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Abscompression
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TABSCompressionAlgorithm { acaNone, acaZLIB, acaBZIP, acaPPM };
#pragma option pop

typedef AnsiString ABSCompression__1[4];

typedef Byte TABSCompressionMode;

#pragma option push -b-
enum TABSCompressionLevel { aclNone, aclFastest, aclNormal, aclMaximum };
#pragma option pop

#pragma pack(push,1)
struct TABSCompression
{
	
public:
	TABSCompressionAlgorithm CompressionAlgorithm;
	Byte CompressionMode;
	TABSCompressionLevel CompressionLevel;
} ;
#pragma pack(pop)

typedef void __fastcall (__closure *TABSNoCancelProgressEvent)(System::TObject* Sender, double PercentDone);

class DELPHICLASS TABSStream;
class PASCALIMPLEMENTATION TABSStream : public Classes::TStream 
{
	typedef Classes::TStream inherited;
	
private:
	_RTL_CRITICAL_SECTION FCSect;
	int FBlockSize;
	TABSNoCancelProgressEvent FOnProgress;
	bool FModified;
	
protected:
	void __fastcall DoOnProgress(double Progress);
	
public:
	virtual void __fastcall Lock(void);
	virtual void __fastcall Unlock(void);
	__fastcall TABSStream(void);
	void __fastcall SaveToStream(TABSStream* Stream);
	void __fastcall LoadFromStreamWithPosition(TABSStream* Stream, __int64 FromPosition, __int64 StreamSize);
	void __fastcall LoadFromStream(TABSStream* Stream);
	void __fastcall LoadFromFile(const AnsiString FileName);
	void __fastcall SaveToFile(const AnsiString FileName);
	__property int BlockSize = {read=FBlockSize, write=FBlockSize, nodefault};
	__property TABSNoCancelProgressEvent OnProgress = {read=FOnProgress, write=FOnProgress};
	__property bool Modified = {read=FModified, write=FModified, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSStream(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSMemoryStream;
class PASCALIMPLEMENTATION TABSMemoryStream : public TABSStream 
{
	typedef TABSStream inherited;
	
private:
	char *FBuffer;
	int FBufferSize;
	int FAllocatedBufferSize;
	int FPosition;
	
protected:
	void __fastcall InternalSetSize(const __int64 NewSize);
	int __fastcall InternalSeek(int NewPosition);
	virtual void __fastcall SetSize(int NewSize)/* overload */;
	virtual void __fastcall SetSize(const __int64 NewSize)/* overload */;
	
public:
	virtual int __fastcall Read(void *Buffer, int Count);
	virtual int __fastcall Write(const void *Buffer, int Count);
	virtual int __fastcall Seek(int Offset, Word Origin)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, Classes::TSeekOrigin Origin)/* overload */;
	__fastcall TABSMemoryStream(char * Buffer, int DefaultAllocatedSize);
	__fastcall virtual ~TABSMemoryStream(void);
	__property char * Buffer = {read=FBuffer};
};


class DELPHICLASS TABSFileStream;
class PASCALIMPLEMENTATION TABSFileStream : public TABSStream 
{
	typedef TABSStream inherited;
	
private:
	int FHandle;
	AnsiString FFileName;
	Word FMode;
	bool FIsTemporary;
	
protected:
	int __fastcall InternalFileCreate(const AnsiString FileName);
	void __fastcall InternalSetSize(const __int64 NewSize);
	virtual void __fastcall SetSize(int NewSize)/* overload */;
	virtual void __fastcall SetSize(const __int64 NewSize)/* overload */;
	
public:
	virtual int __fastcall Read(void *Buffer, int Count);
	virtual int __fastcall Write(const void *Buffer, int Count);
	virtual int __fastcall Seek(int Offset, Word Origin)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, Classes::TSeekOrigin Origin)/* overload */;
	__fastcall TABSFileStream(const AnsiString FileName, Word Mode, bool IsTemporary);
	__fastcall virtual ~TABSFileStream(void);
	__property int Handle = {read=FHandle, nodefault};
	__property AnsiString FileName = {read=FFileName};
	__property Word Mode = {read=FMode, nodefault};
	__property bool IsTemporary = {read=FIsTemporary, nodefault};
};


class DELPHICLASS TABSTemporaryStream;
class PASCALIMPLEMENTATION TABSTemporaryStream : public TABSStream 
{
	typedef TABSStream inherited;
	
private:
	int FMemoryLimit;
	TABSMemoryStream* FMemoryStream;
	TABSFileStream* FFileStream;
	AnsiString FFileName;
	bool FInMemory;
	bool FDisableTempFiles;
	
protected:
	void __fastcall InternalSetSize(const __int64 NewSize);
	virtual void __fastcall SetSize(int NewSize)/* overload */;
	virtual void __fastcall SetSize(const __int64 NewSize)/* overload */;
	
public:
	virtual int __fastcall Read(void *Buffer, int Count);
	virtual int __fastcall Write(const void *Buffer, int Count);
	virtual int __fastcall Seek(int Offset, Word Origin)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, Classes::TSeekOrigin Origin)/* overload */;
	__fastcall TABSTemporaryStream(bool DisableTempFiles);
	__fastcall virtual ~TABSTemporaryStream(void);
	__property TABSFileStream* FileStream = {read=FFileStream};
	__property TABSMemoryStream* MemoryStream = {read=FMemoryStream};
	__property AnsiString FileName = {read=FFileName};
	__property bool InMemory = {read=FInMemory, nodefault};
	__property int MemoryLimit = {read=FMemoryLimit, write=FMemoryLimit, nodefault};
};


class DELPHICLASS TABSCompressedBLOBStream;
class PASCALIMPLEMENTATION TABSCompressedBLOBStream : public TABSStream 
{
	typedef TABSStream inherited;
	
private:
	bool FRepair;
	Abstypes::TABSCompressedStreamBlockHeadersArray* FHeaders;
	__int64 FUncompressedSize;
	__int64 FCompressedSize;
	__int64 FStartPosition;
	int FCurrentHeader;
	__int64 FPosition;
	Byte FCompressionMode;
	TABSCompressionAlgorithm FCompressionAlgorithm;
	double FCompressionRate;
	Classes::TStream* FCompressedStream;
	#pragma pack(push,1)
	Abstypes::TABSBLOBDescriptor FBLOBDescriptor;
	#pragma pack(pop)
	int __fastcall InternalGetBlockSize(Byte CompressionMode);
	void __fastcall CalculateRate(void);
	void __fastcall InternalCreate(bool ToCreate);
	void __fastcall LoadHeaders(void);
	void __fastcall PrepareBufferForWriting(char * InBuf, int InSize, char * &OutBuf, Abstypes::TABSCompressedStreamBlockHeader &Header);
	void __fastcall LoadBlock(__int64 CurHeader, char * &OutBuf);
	void __fastcall InternalIncreaseSize(__int64 NewSize);
	void __fastcall InternalDecreaseSize(__int64 NewSize);
	void __fastcall InternalSetSize(__int64 NewSize);
	__int64 __fastcall InternalSeek(__int64 NewPosition);
	
protected:
	virtual void __fastcall SetSize(int NewSize)/* overload */;
	virtual void __fastcall SetSize(const __int64 NewSize)/* overload */;
	__int64 __fastcall GetCompressedSize(void);
	double __fastcall GetCompressionRate(void);
	
public:
	__fastcall TABSCompressedBLOBStream(Classes::TStream* Stream, const Abstypes::TABSBLOBDescriptor &BLOBDescriptor, bool ToCreate, bool ToRepair);
	__fastcall virtual ~TABSCompressedBLOBStream(void);
	virtual int __fastcall Read(void *Buffer, int Count);
	
private:
	void __fastcall InternalWriteBeyondEOF(void);
	void __fastcall InternalWriteBlock(char * InBuf, int InSize);
	void __fastcall InternalWritePrepare(int Count, int Result);
	
public:
	virtual int __fastcall Write(const void *Buffer, int Count);
	virtual int __fastcall Seek(int Offset, Word Origin)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, Classes::TSeekOrigin Origin)/* overload */;
	__property Classes::TStream* CompressedStream = {read=FCompressedStream};
	__property double CompressionRate = {read=GetCompressionRate};
	__property TABSCompressionAlgorithm CompressionAlgorithm = {read=FCompressionAlgorithm, nodefault};
	__property Byte CompressionMode = {read=FCompressionMode, nodefault};
	__property __int64 CompressedSize = {read=GetCompressedSize};
	__property Abstypes::TABSBLOBDescriptor BLOBDescriptor = {read=FBLOBDescriptor};
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE AnsiString ABSCompressionAlgorithmNames[4];
extern PACKAGE int DefaultTemporaryBlockSize;
extern PACKAGE int DefaultTemporaryLimit;
extern PACKAGE int DefaultMemoryBlockSize;
extern PACKAGE int DefaultFileBlockSize;
extern PACKAGE int DefaultBLOBBlockSize;
extern PACKAGE int BlockSizeForFastest;
extern PACKAGE int BlockSizeForNormal;
extern PACKAGE int BlockSizeForMax;
extern PACKAGE Byte PPM_MO[9];
extern PACKAGE Byte PPM_SA[9];
extern PACKAGE bool __fastcall ABSInternalCompressBuffer(TABSCompressionAlgorithm CompressionAlgorithm, Byte CompressionMode, char * InBuf, int InSize, /* out */ char * &OutBuf, /* out */ int &OutSize);
extern PACKAGE bool __fastcall ABSInternalDecompressBuffer(TABSCompressionAlgorithm CompressionAlgorithm, char * InBuf, int InSize, /* out */ char * &OutBuf, /* out */ int &OutSize);
extern PACKAGE unsigned __fastcall CRC32(unsigned CRC, void * Data, unsigned DataSize);
extern PACKAGE AnsiString __fastcall GetTempFileName();
extern PACKAGE void __fastcall SaveDataToStream(void *Data, int DataSize, Classes::TStream* Stream, int ErrorCode);
extern PACKAGE void __fastcall LoadDataFromStream(void *Data, int DataSize, Classes::TStream* Stream, int ErrorCode);
extern PACKAGE void __fastcall SetStreamPosition(Classes::TStream* Stream, __int64 NewPosition, int ErrorCode);
extern PACKAGE TABSCompressionAlgorithm __fastcall GetCompressionAlgorithm(AnsiString Name);

}	/* namespace Abscompression */
using namespace Abscompression;
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Abscompression