ean128logicimpl.java

生成二维条形码的java程序

//                code128Msg.append(cd1);
//            } else if (ai.checkDigit[i] == CheckDigit.CDNone || !doChecksumADD) {
            if (doChecksumADD && i == ai.type.length - 1) { //ai.checkDigit[i] != CheckDigit.CDNone) {
                char c = CheckDigit.calcCheckdigit(msg, 
                        startA[ai.checkDigitStart[i]], start, CheckDigit.CD31);
                humanReadableMsg.append(c);
                code128Msg.append(c);
                if (newOffset < msg.length() 
                    && (msg.charAt(newOffset) == groupSeparator 
                            || msg.charAt(newOffset) == Code128LogicImpl.FNC_1)) {
                    newOffset++;
                }
            } else {
                checkType(ai, i, msg, start, end, startA[ai.checkDigitStart[i]]);
//                humanReadableMsg.append(msg.substring(startI, end));
//                code128Msg.append(msg.substring(startI, end));
            }
        }
//        if (doChecksumADD) {
//            char c = CheckDigit.calcCheckdigit(msg, cdStart, newOffset, ai.checkDigit[ai.checkDigit.length-1]);
//            humanReadableMsg.append(c);
//            code128Msg.append(c);
//            if (newOffset < msg.length() && msg.charAt(newOffset) == groupSeparator) {
//                newOffset++;
//            }
//        }
        if (newOffset < msg.length()
                && (msg.charAt(newOffset) == groupSeparator
                        || msg.charAt(newOffset) == Code128LogicImpl.FNC_1)) {
            //TODO Needed for 8001?...
            newOffset++;
//            code128Msg.append(Code128LogicImpl.FNC_1);
        }
        if (!ai.fixed && newOffset < msg.length()) {
            code128Msg.append(Code128LogicImpl.FNC_1);
        }
        return newOffset;
        //TODO check that every id appears only once in the barcode
        //TODO check that encodedMsg is never larger than 35
        //TODO check that message never larger than 48 (does this include all groupSeparator?)
        //TODO show only 13 digits of the EAN in human readable part (if the first digit is '0')   
    }

    private void checkType(EAN128AI ai, byte idx, String msg, int start, int end, int cdStart) {
        byte type = ai.type[idx]; 
        if (type == EAN128AI.TYPEError) {
            throw getException("This AI is not allowed by configuration! (" 
                + ai.toString() + ")");
            
        } else if (type == EAN128AI.TYPEAlpha) {
            for (int i = end - 1; i >= start; i--) {
                if (msg.charAt(i) > 128 || Character.isDigit(msg.charAt(i))) {
                    throw getException("Character \'" + msg.charAt(i) 
                            + "\' must be a valid ASCII byte but not number!",
                            msg.substring(start, i));
                }
            }
        } else if (type == EAN128AI.TYPEAlphaNum) {
            for (int i = end - 1; i >= start; i--) {
                if (msg.charAt(i) > 128) {
                    throw getException("Character \'" + msg.charAt(i) 
                            + "\' must be a valid ASCII byte!",
                            msg.substring(start, i));
                }
            }
        } else {
            if (ai.isCheckDigit(idx) && checksumCHECK) {
                char cd1 = CheckDigit.calcCheckdigit(msg, cdStart, start, CheckDigit.CD31);
                char cd2 = msg.charAt(start);
                if (cd2 == checkDigitMarker) {
                    cd2 = cd1;
                }
                if (cd1 != cd2) {
                    throw getException("Checkdigit is wrong! Correct is " + cd1  
                        + " but I found " + cd2 + "!");
                }
                humanReadableMsg.append(cd1);
                code128Msg.append(cd1);
                return;                        
            }
            for (int i = end - 1; i >= start; i--) {
                if (!Character.isDigit(msg.charAt(i))) {
                    throw getException("Character \'" + msg.charAt(i) 
                        + "\' must be a Digit!",
                        msg.substring(start, i));
                }
            }
            if (type == EAN128AI.TYPENumDate) {
                char cm1 = msg.charAt(start + 2), cm2 = msg.charAt(start + 3);
                char cd1 = msg.charAt(start + 4), cd2 = msg.charAt(start + 5);
                if ((cm1 == '0' && cm2 == '0')
                        || (cm1 == '1' && cm2 > '2')
                        || cm1 > '1') {
                    throw getException("Illegal Month \"" + cm1 + cm2 + "\"!", 
                        msg.substring(start, start + 2));
                }
                if ((cd1 == '3' && cd2 > '1') || cd1 > '3') {
                    throw getException("Illegal Day \"" + cd1 + cd2 + "\"!", 
                        msg.substring(start, start + 4));
                }
            }
        }    
        humanReadableMsg.append(msg.substring(start, end));
        code128Msg.append(msg.substring(start, end));
    }

    private char getIDChar(String msg, int offset) {
        char ret;
        try {
            ret = msg.charAt(offset);
        } catch (Exception e) {
            throw getException("Unable to read last ID: Message too short!");
        }
        if (!Character.isDigit(ret)) {
            throw getException("Unable to read last ID: Characters must be numerical!");
        }
        return ret;
    }

    private IllegalArgumentException getException(String text) {
        return getException(text, "");
    }
    
    private IllegalArgumentException getException(String text, String msgOk) {
        if (msgOk == null) {
            msgOk = "";
        }
        if (humanReadableMsg.length() > 1 || msgOk.length() > 0) { 
            text = text + " Accepted start of Message: \"" 
                + humanReadableMsg.toString() + msgOk + "\"";
        }
        exception = new IllegalArgumentException(text);
        return exception;
    }


    public String getCode128Msg() {
        return code128Msg.toString();
    }
    
    public String getHumanReadableMsg() {
        return humanReadableMsg.toString();
    }
    
    /** {@inheritDoc} */
    public String toString() {
        return getHumanReadableMsg();
    }

    public void setChecksumMode(ChecksumMode mode) {
        if (mode == ChecksumMode.CP_AUTO) {
            checksumADD = true;
            checksumCHECK = true;
        } else if (mode == ChecksumMode.CP_ADD) {
            checksumADD = true;
            checksumCHECK = false;
        } else if (mode == ChecksumMode.CP_CHECK) {
            checksumADD = false;
            checksumCHECK = false;
        } else {
            checksumADD = false;
            checksumCHECK = false;
            //Shouldn't happen because of validateMessage
            throw new RuntimeException("Internal error");
        }
    }
    /**
     * @return
     */
    public char getGroupSeparator() {
        return groupSeparator;
    }

    /**
     * @param c
     */
    public void setGroupSeparator(char c) {
        groupSeparator = c;
    }

    /**
     * @param string
     */
    public void setTemplate(String string) {
        EAN128AI[] newTemplates = null;
        if (string == null || string.trim().length() == 0) {
            return;
        }
        StringTokenizer st = new StringTokenizer(string, "()", false);
        int count = st.countTokens();
        if (count % 2 != 0) {
            throw new IllegalArgumentException("Cannot parse template: \"" + string);
        }
        count /= 2;
        newTemplates = new EAN128AI[count];
        for (int i = 0; i < count; i++) {
            newTemplates[i] = EAN128AI.parseSpec(st.nextToken(), st.nextToken());
        }
        ais = newTemplates; 
    }
    /**
     * @return
     */
    public char getCheckDigitMarker() {
        return checkDigitMarker;
    }

    /**
     * @param c
     */
    public void setCheckDigitMarker(char c) {
        checkDigitMarker = c;
    }

    /**
     * @return
     */
    public boolean isOmitBrackets() {
        return omitBrackets;
    }

    /**
     * @param b
     */
    public void setOmitBrackets(boolean b) {
        omitBrackets = b;
    }

}