java/src/liba/crc8.java

   1 package liba;
   2
   3 import java.nio.ByteBuffer;
   4
   5 /** 8-bit Cyclic Redundancy Check */
   6 public class crc8 {
   7     ByteBuffer ctx;
   8     static {
   9         System.loadLibrary("a");
  10         clinit();
  11     }
  12
  13     static final native void clinit();
  14
  15     final native void init(byte poly, boolean reversed);
  16
  17     /**
  18      * construct a new {@link crc8} object
  19      *
  20      * @param poly polynomial that is CRC's divisor
  21      */
  22     public crc8(byte poly) {
  23         init(poly, false);
  24     }
  25
  26     /**
  27      * construct a new {@link crc8} object
  28      *
  29      * @param poly     polynomial that is CRC's divisor
  30      * @param reversed is reversed?
  31      */
  32     public crc8(byte poly, boolean reversed) {
  33         init(poly, reversed);
  34     }
  35
  36     /**
  37      * get table for 8-bit Cyclic Redundancy Check
  38      *
  39      * @return filter coefficient [0,1]
  40      */
  41     public final native byte[] table();
  42
  43     /**
  44      * generate for 8-bit Cyclic Redundancy Check
  45      *
  46      * @param poly     polynomial that is CRC's divisor
  47      * @param reversed is reversed?
  48      * @return {@link crc8}
  49      */
  50     public final native crc8 gen(byte poly, boolean reversed);
  51
  52     /**
  53      * calculate for 8-bit Cyclic Redundancy Check
  54      *
  55      * @param block block to be processed
  56      * @param value initial value
  57      * @return output value
  58      */
  59     public final native byte eval(byte[] block, byte value);
  60
  61     /**
  62      * calculate for 8-bit Cyclic Redundancy Check
  63      *
  64      * @param block block to be processed
  65      * @return output value
  66      */
  67     public byte eval(byte[] block) {
  68         return eval(block, (byte) 0);
  69     }
  70
  71     /**
  72      * pack a block and its CRC-8 value
  73      *
  74      * @param block block to be processed
  75      * @param value initial value
  76      * @return packed block
  77      */
  78     public final native byte[] pack(byte[] block, byte value);
  79
  80     /**
  81      * pack a block and its CRC-8 value
  82      *
  83      * @param block block to be processed
  84      * @return packed block
  85      */
  86     public byte[] pack(byte[] block) {
  87         return pack(block, (byte) 0);
  88     }
  89 }