Examples of com.ibm.icu.text.UnicodeDecompressor

com.ibm.icu.text.UnicodeDecompressor

nicode.org/unicode/reports/tr6">Unicode Technical Report #6.

USAGE

The static methods on UnicodeDecompressor may be used in a straightforward manner to decompress simple strings:

 byte [] compressed = ... ; // get compressed bytes from somewhere String result = UnicodeDecompressor.decompress(compressed);

The static methods have a fairly large memory footprint. For finer-grained control over memory usage, UnicodeDecompressor offers more powerful APIs allowing iterative decompression:

 // Decompress an array "bytes" of length "len" using a buffer of 512 chars // to the Writer "out" UnicodeDecompressor myDecompressor         = new UnicodeDecompressor(); final static int    BUFSIZE                = 512; char []             charBuffer             = new char [ BUFSIZE ]; int                 charsWritten           = 0; int []              bytesRead              = new int [1]; int                 totalBytesDecompressed = 0; int                 totalCharsWritten      = 0; do { // do the decompression charsWritten = myDecompressor.decompress(bytes, totalBytesDecompressed,  len, bytesRead, charBuffer, 0, BUFSIZE); // do something with the current set of chars out.write(charBuffer, 0, charsWritten); // update the no. of bytes decompressed totalBytesDecompressed += bytesRead[0]; // update the no. of chars written totalCharsWritten += charsWritten; } while(totalBytesDecompressed < len); myDecompressor.reset(); // reuse decompressor

Decompression is performed according to the standard set forth in Unicode Technical Report #6

@see UnicodeCompressor @author Stephen F. Booth @stable ICU 2.4

    }


    /** Decompress the two segments */
    private String decompressTest(byte [] segment1, byte [] segment2) {
        StringBuffer s = new StringBuffer();
        UnicodeDecompressor myDecompressor = new UnicodeDecompressor();


        int [] bytesRead = new int[1];
        char [] charBuffer = new char [2*(segment1.length + segment2.length)];
        int count1 = 0, count2 = 0;


        count1 = myDecompressor.decompress(segment1, 0, segment1.length,
                                           bytesRead,
                                           charBuffer, 0, charBuffer.length);
        
        logln("Segment 1 (" + segment1.length + " bytes) " +
                "decompressed into " + count1  + " chars");
        logln("Bytes consumed: " + bytesRead[0]);


        logln("Got chars: ");
        logln(charBuffer, 0, count1);
        s.append(charBuffer, 0, count1);


        count2 = myDecompressor.decompress(segment2, 0, segment2.length,
                                           bytesRead,
                                           charBuffer, count1, 
                                           charBuffer.length);
        
        logln("Segment 2 (" + segment2.length + " bytes) " +

View Full Code Here

            myTest(fTestCases[i].toCharArray(), fTestCases[i].length());
        }
    }
    private void myTest(char[] chars, int len) {
        UnicodeCompressor myCompressor = new UnicodeCompressor();
        UnicodeDecompressor myDecompressor = new UnicodeDecompressor();
        
        // variables for my compressor
        int myByteCount = 0;
        int myCharCount = 0;
        int myCompressedSize = Math.max(512, 3*len);
        byte[] myCompressed = new byte[myCompressedSize];
        int myDecompressedSize = Math.max(2, 2 * len);
        char[] myDecompressed = new char[myDecompressedSize];
        int[] unicharsRead = new int[1];
        int[] bytesRead = new int[1];
        
        myByteCount = myCompressor.compress(chars, 0, len, unicharsRead,
                myCompressed, 0, myCompressedSize);


        myCharCount = myDecompressor.decompress(myCompressed, 0, myByteCount,
                bytesRead, myDecompressed, 0, myDecompressedSize);


        if (logDiffs(chars, len, myDecompressed, myCharCount) == false) {
            logln(len + " chars ===> " 
                    + myByteCount + " bytes ===> "

View Full Code Here

            myMultipassTest(fTestCases[i].toCharArray(), fTestCases[i].length());
        }
    }
    private void myMultipassTest(char [] chars, int len) throws Exception {
        UnicodeCompressor myCompressor = new UnicodeCompressor();
        UnicodeDecompressor myDecompressor = new UnicodeDecompressor();
        
        // variables for my compressor
        
        // for looping
        int byteBufferSize = 4;//Math.max(4, len / 4);
        byte[] byteBuffer = new byte [byteBufferSize];
        // real target
        int compressedSize = Math.max(512, 3 * len);
        byte[] compressed = new byte[compressedSize];


        // for looping
        int unicharBufferSize = 2;//byteBufferSize;
        char[] unicharBuffer = new char[unicharBufferSize];
        // real target
        int decompressedSize = Math.max(2, 2 * len);
        char[] decompressed = new char[decompressedSize];


        int bytesWritten = 0;
        int unicharsWritten = 0;


        int[] unicharsRead = new int[1];
        int[] bytesRead = new int[1];
        
        int totalCharsCompressed = 0;
        int totalBytesWritten = 0;


        int totalBytesDecompressed  = 0;
        int totalCharsWritten = 0;


        // not used boolean err = false;




        // perform the compression in a loop
        do {
            
            // do the compression
            bytesWritten = myCompressor.compress(chars, totalCharsCompressed, 
                   len, unicharsRead, byteBuffer, 0, byteBufferSize);


            // copy the current set of bytes into the target buffer
            System.arraycopy(byteBuffer, 0, compressed, 
                   totalBytesWritten, bytesWritten);
            
            // update the no. of characters compressed
            totalCharsCompressed += unicharsRead[0];
            
            // update the no. of bytes written
            totalBytesWritten += bytesWritten;
            
            /*System.out.logln("Compression pass complete.  Compressed "
                               + unicharsRead[0] + " chars into "
                               + bytesWritten + " bytes.");*/
        } while(totalCharsCompressed < len);


        if (totalCharsCompressed != len) {
            errln("ERROR: Number of characters compressed("
                    + totalCharsCompressed + ") != len(" + len + ")");
        } else {
            logln("MP: " + len + " chars ===> " + totalBytesWritten + " bytes.");
        }
        
        // perform the decompression in a loop
        do {
            
            // do the decompression
            unicharsWritten = myDecompressor.decompress(compressed, 
                    totalBytesDecompressed, totalBytesWritten, 
                    bytesRead, unicharBuffer, 0, unicharBufferSize);


            // copy the current set of chars into the target buffer
            System.arraycopy(unicharBuffer, 0, decompressed,

View Full Code Here

TOP

Related Classes of com.ibm.icu.text.UnicodeDecompressor

com.ibm.icu.dev.test.compression.DecompressionTest

com.ibm.icu.dev.test.compression.ExhaustiveTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.