/* 
** DeltaRowCompression.h
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net.
** All rights reserved.
** Distributed under the terms of the MIT License.
*/
#ifndef _DELTA_ROW_COMPRESSION_H
#define _DELTA_ROW_COMPRESSION_H
 
 
#include <Debug.h>
 
 
class AbstractDeltaRowCompressor {
public:
						AbstractDeltaRowCompressor(int rowSize,
							uchar initialSeed);
	virtual				~AbstractDeltaRowCompressor();
	
	// InitCheck returns B_OK on successful construction of this object or 
	// B_NO_MEMORY if the buffer for the seed row could not be allocated.
			status_t	InitCheck();
	
	// Clears the seed row to the initial seed specified in the constructor
			void		Reset();
	
	// Returns the size of the delta row. 
	// The size is 0 if the row is equal to the seed row (previous row).
	// The seed row is updated only if updateSeedRow is true.
			int			CalculateSize(const uchar* row,
							bool updateSeedRow = false);
	
	// Compresses the row using the delta row compression algorithm.
	// The seed row is updated.
			void		Compress(const uchar* row);
 
protected:
	// append byte to delta row
	virtual	void		AppendByteToDeltaRow(uchar byte) = 0;
	
	// returns the current size of the delta row
	inline	int			CurrentDeltaRowSize()
						{
							return fDeltaRowIndex;
						}
 
private:
	// Returns the index where seed row and row differ 
	// or -1 if both arrays are equal.
	inline	int			DiffersIndex(const uchar* row, int index)
						{
							while (index < fSize) {
								if (fSeedRow[index] != row[index])
									return index;
								index ++;
							}
							return -1;
						}
 
	// Returns the number of bytes that row differs from seed row 
	// starting at the specified index.
	inline	int			DiffersLength(const uchar* row, int index)
						{
							int startIndex = index;
							while (index < fSize) {
								if (fSeedRow[index] == row[index])
									break;
								index ++;
							}
							return index - startIndex;
						}
 
	// Compresses row with delta row compression algorithm.
	// The seed row is updated only if updateSeedRow is true.
	// If updateDeltaRow is true the method AppendByteToDeltaRow is called.
			int 		CompressRaw(const uchar* row, bool updateSeedRow,
							bool updateDeltaRow);
 
	// write byte to delta row and calculate size of delta row
			void		Put(uchar byte)
						{
							if (fUpdateDeltaRow)
								AppendByteToDeltaRow(byte);
							fDeltaRowIndex ++;
						}
 
			uchar*		fSeedRow; // the seed row
			int			fSize; // the size of the seed row in bytes
			uchar		fInitialSeed;
							// the value to initialize the seed row with
 
			int			fDeltaRowIndex;
							// the index of the next byte to be written into
							// the delta row
			bool		fUpdateDeltaRow; // write delta row
};
 
 
class DeltaRowCompressor : public AbstractDeltaRowCompressor
{
public:
						DeltaRowCompressor(int rowSize, uchar initialSeed)
						:
						AbstractDeltaRowCompressor(rowSize, initialSeed)
						{}
	
	// The delta row to be written to.
			void		SetDeltaRow(uchar* deltaRow)
						{
							fDeltaRow = deltaRow;
						}
	
protected:
	virtual	void		AppendByteToDeltaRow(uchar byte)
						{
							fDeltaRow[CurrentDeltaRowSize()] = byte;
						}	
 
private:
			uchar*		fDeltaRow; // the delta row
};
 
#endif