Application: gvSIG desktop

from java import util, lang

import jarray, binascii

class error(Exception):

    pass

DEFLATED = 8

MAX_WBITS = 15

DEF_MEM_LEVEL = 8

ZLIB_VERSION = "1.1.3"

Z_BEST_COMPRESSION = 9

Z_BEST_SPEED = 1

Z_FILTERED = 1

Z_HUFFMAN_ONLY = 2

Z_DEFAULT_COMPRESSION = -1

Z_DEFAULT_STRATEGY = 0

# Most options are removed because java does not support them

# Z_NO_FLUSH = 0

# Z_SYNC_FLUSH = 2

# Z_FULL_FLUSH = 3

Z_FINISH = 4

def adler32(string, value=1):

    if value != 1:

        raise ValueError, "adler32 only support start value of 1"

    checksum = util.zip.Adler32()

    checksum.update(lang.String.getBytes(string))

    return lang.Long(checksum.getValue()).intValue()

def crc32(string, value=0):

    return binascii.crc32(string, value)

def compress(string, level=6):

    if level < Z_BEST_SPEED or level > Z_BEST_COMPRESSION:

        raise error, "Bad compression level"

    deflater = util.zip.Deflater(level, 0)

    deflater.setInput(string, 0, len(string))

    deflater.finish()

    return _get_deflate_data(deflater)

def decompress(string, wbits=0, bufsize=16384):

    inflater = util.zip.Inflater(wbits < 0)

    inflater.setInput(string)

    return _get_inflate_data(inflater)

class compressobj:

    def __init__(self, level=6, method=DEFLATED, wbits=MAX_WBITS,

                       memLevel=0, strategy=0):

        if abs(wbits) > MAX_WBITS or abs(wbits) < 8:

            raise ValueError, "Invalid initialization option"

        self.deflater = util.zip.Deflater(level, wbits < 0)

        self.deflater.setStrategy(strategy)

        if wbits < 0:

            _get_deflate_data(self.deflater)

    def compress(self, string):

        self.deflater.setInput(string, 0, len(string))

        return _get_deflate_data(self.deflater)

    def flush(self, mode=Z_FINISH):

        if mode != Z_FINISH:

            raise ValueError, "Invalid flush option"

        self.deflater.finish()

        return _get_deflate_data(self.deflater)

class decompressobj:

    def __init__(self, wbits=0):

        if abs(wbits) > MAX_WBITS or abs(wbits) < 8:

            raise ValueError, "Invalid initialization option"

        self.inflater = util.zip.Inflater(wbits < 0)

        self.unused_data = ""

    def decompress(self, string):

        self.inflater.setInput(string)

        r = _get_inflate_data(self.inflater)

        # Arrgh. This suck.

        self.unused_data = " " * self.inflater.getRemaining()

        return r

    def flush(self):

        #self.inflater.finish()

        return _get_inflate_data(self.inflater)

def _get_deflate_data(deflater):

    buf = jarray.zeros(1024, 'b')

    sb = lang.StringBuffer()

    while not deflater.finished():

        l = deflater.deflate(buf)

        if l == 0:

            break

        sb.append(lang.String(buf, 0, 0, l))

    return sb.toString()

def _get_inflate_data(inflater):

    buf = jarray.zeros(1024, 'b')

    sb = lang.StringBuffer()

    while not inflater.finished():

        l = inflater.inflate(buf)

        if l == 0:

            break

        sb.append(lang.String(buf, 0, 0, l))

    return sb.toString()