cb8583convertmethod.java

8583 pack and unpack 8583 pro

package com.szzt.trade.zsbank;

import com.szzt.common.SysFunction;


public class CB8583ConvertMethod {
  public CB8583ConvertMethod() {
  }

  public static  int convert_Byte_To_Len(byte[] srcByteArray) {
    if (srcByteArray==null)
      return -1;
    if (srcByteArray.length<=0)
      return -1;

    String sLen = new String(srcByteArray);
    return Integer.parseInt(sLen);
  }

  public static void clearByteArray(byte[] srcByteArray,byte fillValue) {
    if (srcByteArray==null)
      return;
    if (srcByteArray.length<=0)
      return;

    for (int nTempCount=0;nTempCount<srcByteArray.length;nTempCount++)
      srcByteArray[nTempCount]=fillValue;
  }

  public static  byte[] pack_Bit_To_Bit(byte[] srcByteArray,int maxSize) {
    if (srcByteArray==null || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;

    int destArraySize=0;
    if (maxSize % 8 ==0)
      destArraySize=maxSize / 8;
    else
      destArraySize=maxSize /8 +1;
    if (srcByteArray.length < destArraySize)
      return null;

    byte[] destByteArray=new byte[destArraySize];
    clearByteArray(destByteArray,(byte)0x00);
    System.arraycopy(srcByteArray,0,destByteArray,0,destArraySize);
    return destByteArray;
  }

  public static  byte[] pack_Str_To_BCD(byte[] srcByteArray,int maxSize) {
   if (srcByteArray==null || maxSize<=0)
     return null;
   if (srcByteArray.length <=0)
     return null;
   if (srcByteArray.length > maxSize )
     return null;

   byte[] bcdByteArray=SysFunction.convertByteArrayToHexStr(srcByteArray).getBytes();
   if (bcdByteArray==null)
     return null;

   int pLen = maxSize / 2 + maxSize % 2;
   int len = bcdByteArray.length;
   byte[] destByteArray=new byte[pLen];
   if(pLen-len > 0){
     byte[] addedArray = new byte[pLen-len];
     clearByteArray(addedArray,(byte)0x00);
     System.arraycopy(addedArray,0,destByteArray,0,pLen-len);
   }
   System.arraycopy(bcdByteArray,0,destByteArray,pLen-len,len);
   bcdByteArray = null;
   return destByteArray;
 }

 public static  byte[] pack_Str_To_BV2(byte[] srcByteArray,int maxSize) {
   if (srcByteArray==null || maxSize<=0)
     return null;
   if (srcByteArray.length<=0)
     return null;
   if (srcByteArray.length>maxSize)
     return null;

   byte[] bcdByteArray=pack_Str_To_BCD(srcByteArray,srcByteArray.length);
   if (bcdByteArray==null)
     return null;
   if (bcdByteArray.length <=0){
     bcdByteArray = null;
     return null;
   }
   byte[] dataLenArray=SysFunction.convertIntToStr(srcByteArray.length,2).getBytes();
   if (dataLenArray==null){
     bcdByteArray = null;
     return null;
   }
   if (dataLenArray.length!=2){
     bcdByteArray = null;
     dataLenArray = null;
     return null;
   }

   byte[] destByteArray=new byte[bcdByteArray.length+2];
   clearByteArray(destByteArray,(byte)0x00);
   System.arraycopy(dataLenArray,0,destByteArray,0,2);
   System.arraycopy(bcdByteArray,0,destByteArray,2,bcdByteArray.length);
   bcdByteArray = null;
   dataLenArray = null;
   return destByteArray;
 }

 public static  byte[] pack_Str_To_BV3(byte[] srcByteArray,int maxSize) {
   if (srcByteArray==null || maxSize<=0)
     return null;
   if (srcByteArray.length<=0)
     return null;
   if (srcByteArray.length>maxSize)
     return null;

   byte[] bcdByteArray=pack_Str_To_BCD(srcByteArray,srcByteArray.length);
   if (bcdByteArray==null)
     return null;
   if (bcdByteArray.length <=0){
     bcdByteArray = null;
     return null;
   }
   byte[] dataLenArray=SysFunction.convertIntToStr(srcByteArray.length,3).getBytes();
   if (dataLenArray==null){
     bcdByteArray = null;
     return null;
   }
   if (dataLenArray.length!=3){
     bcdByteArray = null;
     dataLenArray = null;
     return null;
   }

   byte[] destByteArray=new byte[bcdByteArray.length+3];
   clearByteArray(destByteArray,(byte)0x00);
   System.arraycopy(dataLenArray,0,destByteArray,0,3);
   System.arraycopy(bcdByteArray,0,destByteArray,3,bcdByteArray.length);
   bcdByteArray = null;
   dataLenArray = null;
   return destByteArray;
 }


  public static  byte[] pack_Str_To_Asc(byte[] srcByteArray,int maxSize) {
    if (srcByteArray==null || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;

    byte[] destByteArray=new byte[maxSize];
    clearByteArray(destByteArray,(byte)0x20);
    if (srcByteArray.length>maxSize)
      System.arraycopy(srcByteArray,0,destByteArray,0,maxSize);
    else
      System.arraycopy(srcByteArray,0,destByteArray,0,srcByteArray.length);
    return destByteArray;
  }

  public static  byte[] pack_Str_To_AscZero(byte[] srcByteArray,int maxSize) {
    if (srcByteArray==null || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;

    byte[] destByteArray=new byte[maxSize];
    clearByteArray(destByteArray,(byte)0x00);
    if (srcByteArray.length>maxSize)
      System.arraycopy(srcByteArray,0,destByteArray,0,maxSize);
    else
      System.arraycopy(srcByteArray,0,destByteArray,0,srcByteArray.length);
    return destByteArray;
  }

  public static  byte[] pack_Str_To_XBCD(byte[] srcByteArray,int maxSize) {
    if (srcByteArray==null || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;

    byte[] tmpByteArray=new byte[srcByteArray.length-1];
    System.arraycopy(srcByteArray,1,tmpByteArray,0,srcByteArray.length-1);
    tmpByteArray = pack_Str_To_BCD(srcByteArray,maxSize);

    byte[] destByteArray=new byte[tmpByteArray.length+1];
    clearByteArray(destByteArray,(byte)0x00);
    destByteArray[0] = srcByteArray[0];
    System.arraycopy(tmpByteArray,0,destByteArray,1,tmpByteArray.length);
    tmpByteArray = null;
    return destByteArray;
  }


  public static  byte[] pack_Str_To_AV2(byte[] srcByteArray,int maxSize) {
    if (srcByteArray==null || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;
    if (srcByteArray.length>maxSize)
      return null;

    byte[] destByteArray=new byte[srcByteArray.length+2];
    clearByteArray(destByteArray,(byte)0x00);
    byte[] tmpLenArray=SysFunction.convertIntToStr(srcByteArray.length,2).getBytes();
    if (tmpLenArray==null)
      return null;
    if (tmpLenArray.length!=2)
      return null;
    System.arraycopy(tmpLenArray,0,destByteArray,0,2);
    System.arraycopy(srcByteArray,0,destByteArray,2,srcByteArray.length);
    tmpLenArray = null;
    return destByteArray;
  }

  public static  byte[] pack_Str_To_AV3(byte[] srcByteArray,int maxSize) {
    if (srcByteArray==null || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;
    if (srcByteArray.length>maxSize)
      return null;

    byte[] destByteArray=new byte[srcByteArray.length+3];
    clearByteArray(destByteArray,(byte)0x00);
    byte[] tmpLenArray=SysFunction.convertIntToStr(srcByteArray.length,3).getBytes();
    if (tmpLenArray==null)
      return null;
    if (tmpLenArray.length!=3)
      return null;
    System.arraycopy(tmpLenArray,0,destByteArray,0,3);
    System.arraycopy(srcByteArray,0,destByteArray,3,srcByteArray.length);
    tmpLenArray = null;
    return destByteArray;
  }

  public static  CB8583UnpackField unpack_Asc_To_Str(byte[] srcByteArray,int startPos,int maxSize) {
    if (srcByteArray==null || startPos<0 || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;
    if (srcByteArray.length-startPos<maxSize)
      return null;

    byte[] destByteArray=new byte[maxSize];
    clearByteArray(destByteArray,(byte)0x00);
    System.arraycopy(srcByteArray,startPos,destByteArray,0,maxSize);
    return new CB8583UnpackField(destByteArray,maxSize);
  }

  public static  CB8583UnpackField unpack_AV2_To_Str(byte[] srcByteArray,int startPos,int maxSize) {
    if (srcByteArray==null || startPos<0 || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;
    if (srcByteArray.length-startPos<2)
      return null;

    byte[] tmpLenArray=new byte[2];
    clearByteArray(tmpLenArray,(byte)0x00);
    System.arraycopy(srcByteArray,startPos,tmpLenArray,0,2);
    int retDataLen=convert_Byte_To_Len(tmpLenArray);
    tmpLenArray = null;
    if (retDataLen<=0)
      return null;
    if (retDataLen>maxSize)
      return null;
    if (srcByteArray.length-startPos-2-retDataLen<0)
      return null;

    byte[] destByteArray=new byte[retDataLen];
    clearByteArray(destByteArray,(byte)0x00);
    System.arraycopy(srcByteArray,startPos+2,destByteArray,0,retDataLen);
    return new CB8583UnpackField(destByteArray,retDataLen+2);
  }

  public static  CB8583UnpackField unpack_AV3_To_Str(byte[] srcByteArray,int startPos,int maxSize) {
    if (srcByteArray==null || startPos<0 || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;
    if (srcByteArray.length-startPos<3)
      return null;

    byte[] tmpLenArray=new byte[3];
    clearByteArray(tmpLenArray,(byte)0x00);
    System.arraycopy(srcByteArray,startPos,tmpLenArray,0,3);
    int retDataLen=convert_Byte_To_Len(tmpLenArray);
    tmpLenArray = null;
    if (retDataLen<=0)
      return null;
    if (retDataLen>maxSize)
      return null;
    if (srcByteArray.length-startPos-3-retDataLen<0)
      return null;

    byte[] destByteArray=new byte[retDataLen];
    clearByteArray(destByteArray,(byte)0x00);
    System.arraycopy(srcByteArray,startPos+3,destByteArray,0,retDataLen);
    return new CB8583UnpackField(destByteArray,retDataLen+3);
  }

  public static  CB8583UnpackField unpack_Bit_To_Bit(byte[] srcByteArray,int startPos,int maxSize) {
    if (srcByteArray==null || startPos<0 || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;

    int destArraySize=0;
    if (maxSize % 8 ==0)
      destArraySize=maxSize / 8;
    else
      destArraySize=maxSize /8 +1;
    if (srcByteArray.length-startPos-destArraySize<0)
      return null;

    byte[] destByteArray=new byte[destArraySize];
    clearByteArray(destByteArray,(byte)0x00);
    System.arraycopy(srcByteArray,startPos,destByteArray,0,destArraySize);
    return new CB8583UnpackField(destByteArray,destArraySize);
  }

  public static  CB8583UnpackField unpack_BCD_To_Str(byte[] srcByteArray,int startPos,int maxSize){
    if (srcByteArray==null || startPos<0 || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;

    int bcdBlockSize=0;
    if (maxSize % 2 !=0)
      bcdBlockSize=maxSize /2 +1;
    else
      bcdBlockSize=maxSize /2;
    if (srcByteArray.length-startPos-bcdBlockSize<0)
      return null;

    byte[] tmpByteArray = new byte[bcdBlockSize];
    System.arraycopy(srcByteArray,startPos,tmpByteArray,0,bcdBlockSize);

    byte[] destByteArray=SysFunction.convertByteArrayToHexStr(tmpByteArray).getBytes();
    tmpByteArray = null;
    return new CB8583UnpackField(destByteArray,bcdBlockSize);
  }


  public static  CB8583UnpackField unpack_BV2_To_Str(byte[] srcByteArray,int startPos,int maxSize) {
    if (srcByteArray==null || startPos<0 || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;
    if (srcByteArray.length -startPos<2)
      return null;

    byte[] dataLenArray=new byte[2];
    System.arraycopy(srcByteArray,startPos,dataLenArray,0,2);
    int dataLen=convert_Byte_To_Len(dataLenArray);
    dataLenArray = null;
    if (dataLen<=0){
      byte[] tmpArray=new byte[1];
      tmpArray[0]=(byte)0x20;
      return new CB8583UnpackField(tmpArray,2);
    }
    if (dataLen>maxSize)
      return null;

    int bcdBlockSize=0;
    if (dataLen % 2 !=0)
      bcdBlockSize=dataLen / 2+1;
    else
      bcdBlockSize=dataLen / 2;
    if (srcByteArray.length -startPos-2-bcdBlockSize<0)
      return null;

    CB8583UnpackField convertResult=unpack_BCD_To_Str(srcByteArray,startPos+2,dataLen);
    if (convertResult==null)
      return null;
    if (convertResult.getRetByteArray()==null || convertResult.getPosIncValue()<=0)
      return null;
    if (convertResult.getRetByteArray().length<=0)
      return null;

    return new CB8583UnpackField(convertResult.getRetByteArray(),bcdBlockSize+2);
  }

  public static  CB8583UnpackField unpack_BV3_To_Str(byte[] srcByteArray,int startPos,int maxSize) {
    if (srcByteArray==null || startPos<0 || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;
    if (srcByteArray.length -startPos<3)
      return null;

    byte[] dataLenArray=new byte[3];
    System.arraycopy(srcByteArray,startPos,dataLenArray,0,3);
    int dataLen=convert_Byte_To_Len(dataLenArray);
    dataLenArray = null;
    if (dataLen<=0)
      return null;
    if (dataLen>maxSize)
      return null;

    int bcdBlockSize=0;
    if (dataLen % 2 !=0)
      bcdBlockSize=dataLen /2 +1;
    else
      bcdBlockSize=dataLen /2;
    if (srcByteArray.length-startPos-3-bcdBlockSize<0)
      return null;

    CB8583UnpackField convertResult=unpack_BCD_To_Str(srcByteArray,startPos+3,dataLen);
    if (convertResult==null)
      return null;
    if (convertResult.getRetByteArray()==null || convertResult.getPosIncValue()<=0)
      return null;
    if (convertResult.getRetByteArray().length<=0)
      return null;

    return new CB8583UnpackField(convertResult.getRetByteArray(),bcdBlockSize+3);
  }

  public static  CB8583UnpackField unpack_XBCD_To_Str(byte[] srcByteArray,int startPos,int maxSize) {
    if (srcByteArray==null || startPos<0 || maxSize<=0)
      return null;
    if (srcByteArray.length<=0)
      return null;

    byte[] signArray = new byte[1];
    System.arraycopy(srcByteArray,startPos,signArray,0,1);

    CB8583UnpackField convertResult=unpack_BCD_To_Str(srcByteArray,startPos+1,maxSize);
    if (convertResult==null){
      signArray = null;
      return null;
    }
    if (convertResult.getRetByteArray()==null || convertResult.getPosIncValue()<=0){
      signArray = null;
      return null;
    }
    if (convertResult.getRetByteArray().length<=0){
      signArray = null;
      return null;
    }
    byte[] destByteArray=new byte[convertResult.getRetByteArray().length+1];
    destByteArray[0] = signArray[0];
    System.arraycopy(convertResult.getRetByteArray(),startPos,destByteArray,0,destByteArray.length-1);
    signArray = null;
    return new CB8583UnpackField(destByteArray,destByteArray.length);
  }





}