Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.ning.compress.lzf.impl;
  
Implementation to use on Big-Endian architectures.
  
  @SuppressWarnings("restriction")
  public final class UnsafeChunkEncoderBE
     extends UnsafeChunkEncoder
 {
     public UnsafeChunkEncoderBE(int totalLength) {
         super(totalLength);
     }
 
     public UnsafeChunkEncoderBE(int totalLengthboolean bogus) {
         super(totalLengthbogus);
     }
 
     @Override
     protected int tryCompress(byte[] inint inPosint inEndbyte[] outint outPos)
     {
         final int[] hashTable = ;
         int literals = 0;
         inEnd -= ;
         final int firstPos = inPos// so that we won't have back references across block boundary
 
         int seen = _getInt(ininPos) >> 16;
         
         while (inPos < inEnd) {
             seen = (seen << 8) + (in[inPos + 2] & 255);
 
             int off = hash(seen);
             int ref = hashTable[off];
             hashTable[off] = inPos;
 
             // First expected common case: no back-ref (for whatever reason)
             if ((ref >= inPos// can't refer forward (i.e. leftovers)
                     || (ref < firstPos// or to previous block
                     || (off = inPos - ref) > 
                     || ((seen << 8) != (_getInt(inref-1) << 8))) {
                 ++inPos;
                 ++literals;
                 if (literals == .) {
                     outPos = _copyFullLiterals(ininPosoutoutPos);
                     literals = 0;
                 }
                 continue;
             }
             // match
             int maxLen = inEnd - inPos + 2;
             if (maxLen > ) {
                 maxLen = ;
             }
             if (literals > 0) {
                 outPos = _copyPartialLiterals(ininPosoutoutPosliterals);
                 literals = 0;
             }
             int len = _findMatchLength(inref+3, inPos+3, ref+maxLen);
             
             --off// was off by one earlier
             if (len < 7) {
                 out[outPos++] = (byte) ((off >> 8) + (len << 5));
             } else {
                 out[outPos++] = (byte) ((off >> 8) + (7 << 5));
                 out[outPos++] = (byte) (len - 7);
             }
             out[outPos++] = (byteoff;
             inPos += len;
             seen = _getInt(ininPos);
             hashTable[hash(seen >> 8)] = inPos;
             ++inPos;
             hashTable[hash(seen)] = inPos;
             ++inPos;
         }
         // try offlining the tail
         return _handleTail(ininPosinEnd+4, outoutPosliterals);
     }
 
     private final static int _getInt(final byte[] infinal int inPos) {
         return .getInt(in + inPos);
     }
 
     /*
     ///////////////////////////////////////////////////////////////////////
     // Methods for finding length of a back-reference
     ///////////////////////////////////////////////////////////////////////
      */
     
     private final static int _findMatchLength(final byte[] inint ptr1int ptr2final int maxPtr1)
     {
         // Expect at least 8 bytes to check for fast case; offline others
         if ((ptr1 + 8) >= maxPtr1) { // rare case, offline
             return _findTailMatchLength(inptr1ptr2maxPtr1);
         }
         // short matches common, so start with specialized comparison
         // NOTE: we know that we have 4 bytes of slack before end, so this is safe:
         int i1 = .getInt(in + ptr1);
         int i2 = .getInt(in + ptr2);
        if (i1 != i2) {
            return 1 + _leadingBytes(i1i2);
        }
        ptr1 += 4;
        ptr2 += 4;
        i1 = .getInt(in + ptr1);
        i2 = .getInt(in + ptr2);
        if (i1 != i2) {
            return 5 + _leadingBytes(i1i2);
        }
        return _findLongMatchLength(inptr1+4, ptr2+4, maxPtr1);
    }
    private final static int _findLongMatchLength(final byte[] inint ptr1int ptr2final int maxPtr1)
    {
        final int base = ptr1 - 9;
        // and then just loop with longs if we get that far
        final int longEnd = maxPtr1-8;
        while (ptr1 <= longEnd) {
            long l1 = .getLong(in + ptr1);
            long l2 = .getLong(in + ptr2);
            if (l1 != l2) {
                return ptr1 - base + (Long.numberOfLeadingZeros(l1 ^ l2) >> 3);
            }
            ptr1 += 8;
            ptr2 += 8;
        }
        // or, if running out of runway, handle last bytes with loop-de-loop...
        while (ptr1 < maxPtr1 && in[ptr1] == in[ptr2]) {
            ++ptr1;
            ++ptr2;
        }
        return ptr1 - base// i.e. 
    }
    private final static int _leadingBytes(int i1int i2) {
        return (Long.numberOfLeadingZeros(i1 ^ i2) >> 3);
    }
New to GrepCode? Check out our FAQ X