From 2a1aa84bd44ef580e24965ea44bec64335e9496a Mon Sep 17 00:00:00 2001 From: jlcout Date: Sun, 6 Dec 2020 21:08:42 -0200 Subject: [PATCH] add GSRN-P implementation and fix SGTIN --- epctagcoder/pom.xml | 2 +- .../option/GSRNP/GSRNPFilterValue.java | 38 +++ .../epctagcoder/option/GSRNP/GSRNPHeader.java | 37 +++ .../option/GSRNP/GSRNPTagSize.java | 36 +++ .../GSRNPPartitionTableList.java | 49 +++ .../SGTINPartitionTableList.java | 17 +- .../org/epctagcoder/parse/CPI/ParseCPI.java | 4 +- .../epctagcoder/parse/GSRNP/ParseGSRNP.java | 306 ++++++++++++++++++ .../epctagcoder/parse/SGTIN/ParseSGTIN.java | 13 +- .../org/epctagcoder/parse/SSCC/ParseSSCC.java | 15 +- .../java/org/epctagcoder/result/Base.java | 11 + 11 files changed, 504 insertions(+), 24 deletions(-) create mode 100644 epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPFilterValue.java create mode 100644 epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPHeader.java create mode 100644 epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPTagSize.java create mode 100644 epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/partitionTable/GSRNPPartitionTableList.java create mode 100644 epctagcoder/src/main/java/org/epctagcoder/parse/GSRNP/ParseGSRNP.java diff --git a/epctagcoder/pom.xml b/epctagcoder/pom.xml index e6d9f27..ba7e8f0 100644 --- a/epctagcoder/pom.xml +++ b/epctagcoder/pom.xml @@ -4,7 +4,7 @@ org.epctagcoder epctagcoder - 0.0.6-SNAPSHOT + 0.0.7-SNAPSHOT jar epctagcoder diff --git a/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPFilterValue.java b/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPFilterValue.java new file mode 100644 index 0000000..453c474 --- /dev/null +++ b/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPFilterValue.java @@ -0,0 +1,38 @@ +package org.epctagcoder.option.GSRNP; + +import java.util.LinkedHashMap; +import java.util.Map; + +public enum GSRNPFilterValue { + ALL_OTHERS_0(0), + RESERVED_1(1), + RESERVED_2(2), + RESERVED_3(3), + RESERVED_4(4), + RESERVED_5(5), + RESERVED_6(6), + RESERVED_7(7); + + private int value; + + private GSRNPFilterValue(int value) { + this.value = value; + } + + public int getValue() { + return value; + } + + private static final Map BY_CODE_MAP = new LinkedHashMap<>(); + static { + for (GSRNPFilterValue rae : GSRNPFilterValue.values()) { + BY_CODE_MAP.put(rae.value, rae); + } + } + + public static GSRNPFilterValue forCode(int code) { + return BY_CODE_MAP.get(code); + } + + +} diff --git a/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPHeader.java b/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPHeader.java new file mode 100644 index 0000000..f1eb460 --- /dev/null +++ b/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPHeader.java @@ -0,0 +1,37 @@ +package org.epctagcoder.option.GSRNP; + +import java.util.LinkedHashMap; +import java.util.Map; + +public enum GSRNPHeader { + HEADER_00101110("00101110") { + public Integer getTagSize() { + return 96; + } + }; + + private String value; + public abstract Integer getTagSize(); + + + private GSRNPHeader(String value) { + this.value = value; + } + + public String getValue() { + return value; + } + + private static final Map BY_CODE_MAP = new LinkedHashMap<>(); + static { + for (GSRNPHeader rae : GSRNPHeader.values()) { + BY_CODE_MAP.put(rae.value, rae); + } + } + + public static GSRNPHeader forCode(String code) { + return BY_CODE_MAP.get(code); + } + + +} diff --git a/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPTagSize.java b/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPTagSize.java new file mode 100644 index 0000000..ba305bb --- /dev/null +++ b/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/GSRNPTagSize.java @@ -0,0 +1,36 @@ +package org.epctagcoder.option.GSRNP; + +import java.util.LinkedHashMap; +import java.util.Map; + +public enum GSRNPTagSize { + BITS_96(96) { + public Integer getHeader() { + return 46; + } + }; + + private int value; + public abstract Integer getHeader(); + + private GSRNPTagSize(int value) { + this.value = value; + } + + public int getValue() { + return value; + } + + private static final Map BY_CODE_MAP = new LinkedHashMap<>(); + static { + for (GSRNPTagSize rae : GSRNPTagSize.values()) { + BY_CODE_MAP.put(rae.value, rae); + } + } + + public static GSRNPTagSize forCode(int code) { + return BY_CODE_MAP.get(code); + } + + +} diff --git a/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/partitionTable/GSRNPPartitionTableList.java b/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/partitionTable/GSRNPPartitionTableList.java new file mode 100644 index 0000000..be30b55 --- /dev/null +++ b/epctagcoder/src/main/java/org/epctagcoder/option/GSRNP/partitionTable/GSRNPPartitionTableList.java @@ -0,0 +1,49 @@ +package org.epctagcoder.option.GSRNP.partitionTable; + +import java.util.ArrayList; +import java.util.List; + +import org.epctagcoder.option.TableItem; + + +public class GSRNPPartitionTableList { + static final private List list = new ArrayList(); + + static { + list.add( new TableItem(0, 40, 12, 18, 5) ); + list.add( new TableItem(1, 37, 11, 21, 6) ); + list.add( new TableItem(2, 34, 10, 24, 7) ); + list.add( new TableItem(3, 30, 9, 28, 8) ); + list.add( new TableItem(4, 27, 8, 31, 9) ); + list.add( new TableItem(5, 24, 7, 34, 10) ); + list.add( new TableItem(6, 20, 6, 38, 11) ); + } + + public GSRNPPartitionTableList() { + + } + + public TableItem getPartitionByL(Integer index) { + TableItem tableItem = null; + for (TableItem item : list) { + if (item.getL()==index) { + tableItem = item; + break; + } + } + return tableItem; + } + + public TableItem getPartitionByValue(Integer index) { + TableItem tableItem = null; + for (TableItem item : list) { + if (item.getPartitionValue()==index) { + tableItem = item; + break; + } + } + return tableItem; + } + + +} diff --git a/epctagcoder/src/main/java/org/epctagcoder/option/SGTIN/partitionTable/SGTINPartitionTableList.java b/epctagcoder/src/main/java/org/epctagcoder/option/SGTIN/partitionTable/SGTINPartitionTableList.java index a6a3607..eb98343 100644 --- a/epctagcoder/src/main/java/org/epctagcoder/option/SGTIN/partitionTable/SGTINPartitionTableList.java +++ b/epctagcoder/src/main/java/org/epctagcoder/option/SGTIN/partitionTable/SGTINPartitionTableList.java @@ -36,14 +36,15 @@ public TableItem getPartitionByL(Integer index) { } public TableItem getPartitionByValue(Integer index) { - TableItem tableItem = null; - for (TableItem item : list) { - if (item.getPartitionValue()==index) { - tableItem = item; - break; - } - } - return tableItem; +// TableItem tableItem = null; + return list.get(index); +// for (TableItem item : list) { +// if (item.getPartitionValue()==index) { +// tableItem = item; +// break; +// } +// } +// return tableItem; } diff --git a/epctagcoder/src/main/java/org/epctagcoder/parse/CPI/ParseCPI.java b/epctagcoder/src/main/java/org/epctagcoder/parse/CPI/ParseCPI.java index 0c47759..f722c93 100644 --- a/epctagcoder/src/main/java/org/epctagcoder/parse/CPI/ParseCPI.java +++ b/epctagcoder/src/main/java/org/epctagcoder/parse/CPI/ParseCPI.java @@ -278,7 +278,7 @@ public static interface componentPartReferenceStep { } public static interface serialStep { - TagSizeStep withserial(String serial); + TagSizeStep withSerial(String serial); } public static interface TagSizeStep { @@ -322,7 +322,7 @@ public FilterValueStep withTagSize(CPITagSize tagSize) { } @Override - public TagSizeStep withserial(String serial) { + public TagSizeStep withSerial(String serial) { this.serial = serial; return this; } diff --git a/epctagcoder/src/main/java/org/epctagcoder/parse/GSRNP/ParseGSRNP.java b/epctagcoder/src/main/java/org/epctagcoder/parse/GSRNP/ParseGSRNP.java new file mode 100644 index 0000000..edf7159 --- /dev/null +++ b/epctagcoder/src/main/java/org/epctagcoder/parse/GSRNP/ParseGSRNP.java @@ -0,0 +1,306 @@ +package org.epctagcoder.parse.GSRNP; + +import java.util.Optional; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.epctagcoder.option.PrefixLength; +import org.epctagcoder.option.TableItem; +import org.epctagcoder.option.GSRNP.GSRNPFilterValue; +import org.epctagcoder.option.GSRNP.GSRNPHeader; +import org.epctagcoder.option.GSRNP.GSRNPTagSize; +import org.epctagcoder.option.GSRNP.partitionTable.GSRNPPartitionTableList; +import org.epctagcoder.result.GSRNP; +import org.epctagcoder.util.Converter; + +public class ParseGSRNP { + private static final Integer RESERVED = 0; // 24 zero bits + private GSRNP gsrnp = new GSRNP(); + private String companyPrefix; + private PrefixLength prefixLength; + private GSRNPTagSize tagSize; + private GSRNPFilterValue filterValue; + private String serviceReference; + private String rfidTag; + private String epcTagURI; + private String epcPureIdentityURI; + private TableItem tableItem; + + public static ChoiceStep Builder() { + return new Steps(); + } + + private ParseGSRNP(Steps steps) { + this.companyPrefix = steps.companyPrefix; + this.tagSize = steps.tagSize; + this.filterValue = steps.filterValue; + this.serviceReference = steps.serviceReference; + this.rfidTag = steps.rfidTag; + this.epcTagURI = steps.epcTagURI; + this.epcPureIdentityURI = steps.epcPureIdentityURI; + parse(); + } + + + private void parse() { + Optional optionalCompanyPrefix = Optional.ofNullable(companyPrefix); + Optional optionalRfidTag = Optional.ofNullable(rfidTag); + Optional optionalEpcTagURI = Optional.ofNullable(epcTagURI); + Optional optionalEpcPureIdentityURI = Optional.ofNullable(epcPureIdentityURI); + + if ( optionalRfidTag.isPresent() ) { + String inputBin = Converter.hexToBin(rfidTag); + String headerBin = inputBin.substring(0, 8); + String filterBin = inputBin.substring(8,11); + String partitionBin = inputBin.substring(11,14); + GSRNPPartitionTableList GSRNPPartitionTableList = new GSRNPPartitionTableList(); + + tableItem = GSRNPPartitionTableList.getPartitionByValue( Integer.parseInt(partitionBin, 2) ); + + String companyPrefixBin = inputBin.substring(14,14+tableItem.getM()); + String serialWithExtensionBin = inputBin.substring(14+tableItem.getM(),14+tableItem.getM()+tableItem.getN()); + String filterDec = Long.toString( Long.parseLong(filterBin, 2) ); + String companyPrefixDec = Converter.binToDec(companyPrefixBin); //Long.toString( Long.parseLong(companyPrefixBin, 2) ); + + serviceReference = Converter.strZero(Converter.binToDec(serialWithExtensionBin), tableItem.getDigits() ); + companyPrefix = Converter.strZero(companyPrefixDec, tableItem.getL()); + filterValue = GSRNPFilterValue.forCode( Integer.parseInt(filterDec) ); + tagSize = GSRNPTagSize.forCode( GSRNPHeader.forCode(headerBin).getTagSize() ); + prefixLength = PrefixLength.forCode(tableItem.getL()); + + } else { + + if ( optionalCompanyPrefix.isPresent() ) { + GSRNPPartitionTableList GSRNPPartitionTableList = new GSRNPPartitionTableList(); + + prefixLength = PrefixLength.forCode( companyPrefix.length() ); + + validateCompanyPrefix(); + + tableItem = GSRNPPartitionTableList.getPartitionByL( prefixLength.getValue() ); + + validateServiceReference(); + + } else { + + if ( optionalEpcTagURI.isPresent() ) { + Pattern pattern = Pattern.compile("(urn:epc:tag:gsrnp-)(96)\\:([0-7])\\.(\\d+)\\.(\\d+)"); + Matcher matcher = pattern.matcher(epcTagURI); + + if ( matcher.matches() ) { + tagSize = GSRNPTagSize.forCode( Integer.parseInt(matcher.group(2)) ); + filterValue = GSRNPFilterValue.forCode( Integer.parseInt(matcher.group(3)) ); + companyPrefix = matcher.group(4); + prefixLength = PrefixLength.forCode( matcher.group(4).length() ); + serviceReference = matcher.group(5); + } else { + throw new IllegalArgumentException("EPC Tag URI is invalid"); + } + + } else if ( optionalEpcPureIdentityURI.isPresent() ) { + Pattern pattern = Pattern.compile("(urn:epc:id:gsrnp)\\:(\\d+)\\.(\\d+)"); + Matcher matcher = pattern.matcher(epcPureIdentityURI); + + if ( matcher.matches() ) { + companyPrefix = matcher.group(2); + prefixLength = PrefixLength.forCode( matcher.group(2).length() ); + serviceReference = matcher.group(3); + } else { + throw new IllegalArgumentException("EPC Pure Identity is invalid"); + } + + + } + + GSRNPPartitionTableList GSRNPPartitionTableList = new GSRNPPartitionTableList(); + tableItem = GSRNPPartitionTableList.getPartitionByL( prefixLength.getValue() ); + + } + + } + + + String outputBin = getBinary(); + String outputHex = Converter.binToHex( outputBin ); + + gsrnp.setEpcScheme("gsrnp"); + gsrnp.setApplicationIdentifier("AI 8017"); + gsrnp.setTagSize(Integer.toString(tagSize.getValue())); + gsrnp.setFilterValue(Integer.toString(filterValue.getValue()) ); + gsrnp.setPartitionValue(Integer.toString(tableItem.getPartitionValue())); + gsrnp.setPrefixLength(Integer.toString(prefixLength.getValue())); + gsrnp.setCompanyPrefix(companyPrefix); + gsrnp.setServiceReference(serviceReference); + gsrnp.setCheckDigit(Integer.toString(getCheckDigit())); + gsrnp.setEpcPureIdentityURI(String.format("urn:epc:id:gsrnp:%s.%s", companyPrefix, serviceReference)); + gsrnp.setEpcTagURI(String.format("urn:epc:tag:gsrnp-%s:%s.%s.%s", tagSize.getValue(), + filterValue.getValue(), companyPrefix, serviceReference)); + gsrnp.setEpcRawURI(String.format("urn:epc:raw:%s.x%s", tagSize.getValue(), outputHex )); + gsrnp.setBinary(outputBin); + gsrnp.setRfidTag(outputHex); + + } + + private Integer getCheckDigit() { + String value = new StringBuilder() + .append(companyPrefix) + .append(serviceReference) + .toString(); + + Integer d18 = (10 - ((3 + * (Character.getNumericValue(value.charAt(0)) + Character.getNumericValue(value.charAt(2)) + + Character.getNumericValue(value.charAt(4)) + Character.getNumericValue(value.charAt(6)) + + Character.getNumericValue(value.charAt(8)) + + Character.getNumericValue(value.charAt(10)) + Character.getNumericValue(value.charAt(12)) + + Character.getNumericValue(value.charAt(14)) + Character.getNumericValue(value.charAt(16))) + + (Character.getNumericValue(value.charAt(1)) + Character.getNumericValue(value.charAt(3)) + + Character.getNumericValue(value.charAt(5)) + Character.getNumericValue(value.charAt(7)) + + Character.getNumericValue(value.charAt(9)) + Character.getNumericValue(value.charAt(11)) + + Character.getNumericValue(value.charAt(13)) + Character.getNumericValue(value.charAt(15)))) + % 10)) % 10; + return d18; + } + + + private String getBinary() { + StringBuilder bin = new StringBuilder(); + + bin.append( Converter.decToBin(tagSize.getHeader(), 8) ); + bin.append( Converter.decToBin(filterValue.getValue(), 3) ); + bin.append( Converter.decToBin(tableItem.getPartitionValue(), 3) ); + bin.append( Converter.decToBin(Integer.parseInt(companyPrefix), tableItem.getM()) ); + //bin.append( Converter.strZero(BigDec2Bin.dec2bin(serviceReference), tableItem.getN()) ); + bin.append( Converter.decToBin(Integer.parseInt(serviceReference), tableItem.getN()) ); + bin.append( Converter.decToBin(RESERVED, 24) ); + + return bin.toString(); + } + + + public GSRNP getGSRNP() { + return gsrnp; + } + + public String getRfidTag() { + return Converter.binToHex( getBinary() ); + } + + + + private void validateServiceReference() { + StringBuilder value = new StringBuilder() + .append(serviceReference); + + if ( value.length()!=tableItem.getDigits() ) { + throw new IllegalArgumentException(String.format("Service Reference \"%s\" has %d length and should have %d length", + serviceReference, value.length(), tableItem.getDigits())); + } + } + + + private void validateCompanyPrefix() { + Optional optionalpPefixLenght = Optional.ofNullable(prefixLength); + if ( !optionalpPefixLenght.isPresent() ) { + throw new IllegalArgumentException("Company Prefix is invalid. Length not found in the partition table"); + } + + } + + + + + public static interface ChoiceStep { + ServiceReferenceStep withCompanyPrefix(String companyPrefix); + BuildStep withRFIDTag(String rfidTag); + BuildStep withEPCTagURI(String epcTagURI); + TagSizeStep withEPCPureIdentityURI(String epcPureIdentityURI); + } + + + public static interface ServiceReferenceStep { + TagSizeStep withServiceReference(String serviceReference); + } + + public static interface TagSizeStep { + FilterValueStep withTagSize( GSRNPTagSize tagSize ); + } + + public static interface FilterValueStep { + BuildStep withFilterValue( GSRNPFilterValue filterValue ); + } + + public static interface BuildStep { + ParseGSRNP build(); + } + + + + private static class Steps implements ChoiceStep, ServiceReferenceStep, TagSizeStep, FilterValueStep, BuildStep { + private String companyPrefix; + private GSRNPTagSize tagSize; + private GSRNPFilterValue filterValue; + private String serviceReference; + private String rfidTag; + private String epcTagURI; + private String epcPureIdentityURI; + + @Override + public ParseGSRNP build() { + return new ParseGSRNP(this); + } + +// @Override +// public SerialStep withExtensionDigit(SSCCExtensionDigit extensionDigit) { +// this.extensionDigit = extensionDigit; +// return this; +// } + + + @Override + public BuildStep withFilterValue(GSRNPFilterValue filterValue) { + this.filterValue = filterValue; + return this; + } + + @Override + public FilterValueStep withTagSize(GSRNPTagSize tagSize) { + this.tagSize = tagSize; + return this; + } + + @Override + public TagSizeStep withServiceReference(String serviceReference) { + this.serviceReference = serviceReference; + return this; + } + + @Override + public ServiceReferenceStep withCompanyPrefix(String companyPrefix) { + this.companyPrefix = companyPrefix; + return this; + } + + @Override + public BuildStep withRFIDTag(String rfidTag) { + this.rfidTag = rfidTag; + return this; + } + + @Override + public BuildStep withEPCTagURI(String epcTagURI) { + this.epcTagURI = epcTagURI; + return this; + } + + @Override + public TagSizeStep withEPCPureIdentityURI(String epcPureIdentityURI) { + this.epcPureIdentityURI = epcPureIdentityURI; + return this; + } + + + + + } + +} diff --git a/epctagcoder/src/main/java/org/epctagcoder/parse/SGTIN/ParseSGTIN.java b/epctagcoder/src/main/java/org/epctagcoder/parse/SGTIN/ParseSGTIN.java index d3728a9..87cf98c 100644 --- a/epctagcoder/src/main/java/org/epctagcoder/parse/SGTIN/ParseSGTIN.java +++ b/epctagcoder/src/main/java/org/epctagcoder/parse/SGTIN/ParseSGTIN.java @@ -68,20 +68,23 @@ private void parse() { String filterDec = Long.toString( Long.parseLong(filterBin, 2) ); String companyPrefixBin = inputBin.substring(14, 14+tableItem.getM()); String itemReferenceWithExtensionBin = inputBin.substring(14+tableItem.getM(), 14+tableItem.getM()+tableItem.getN()); - String serialBin = inputBin.substring(14+tableItem.getM()+tableItem.getN() ); + + String serialBin = inputBin.substring(14+tableItem.getM()+tableItem.getN() ) + .substring(0, tagSize.getSerialBitCount()); + String companyPrefixDec = Converter.binToDec(companyPrefixBin); String itemReferenceWithExtensionDec = Converter.strZero(Converter.binToDec(itemReferenceWithExtensionBin), tableItem.getDigits()); String extensionDec = itemReferenceWithExtensionDec.substring(0,1); - itemReference = itemReferenceWithExtensionDec.substring(1); - + itemReference = itemReferenceWithExtensionDec.substring(1); + if (tagSize.getSerialBitCount()==140) { serialBin = Converter.convertBinToBit(serialBin, 7, 8); serial = Converter.binToString(serialBin); } else if (tagSize.getSerialBitCount()==38) { serial = Converter.binToDec(serialBin); } - + companyPrefix = Converter.strZero(companyPrefixDec, tableItem.getL()); extensionDigit = SGTINExtensionDigit.forCode( Integer.parseInt(extensionDec) ); filterValue = SGTINFilterValue.forCode( Integer.parseInt(filterDec) ); @@ -173,7 +176,7 @@ private String getBinary() { bin.append( Converter.decToBin(tagSize.getHeader(), 8) ); bin.append( Converter.decToBin(filterValue.getValue(), 3) ); bin.append( Converter.decToBin(tableItem.getPartitionValue(), 3) ); - bin.append( Converter.decToBin(Integer.parseInt(companyPrefix), tableItem.getM()) ); + bin.append( Converter.decToBin(companyPrefix, tableItem.getM()) ); bin.append( Converter.decToBin(Integer.parseInt(Integer.toString(extensionDigit.getValue())+itemReference), tableItem.getN()) ); if (tagSize.getValue()==198) { diff --git a/epctagcoder/src/main/java/org/epctagcoder/parse/SSCC/ParseSSCC.java b/epctagcoder/src/main/java/org/epctagcoder/parse/SSCC/ParseSSCC.java index 6e0ab95..84d86f7 100644 --- a/epctagcoder/src/main/java/org/epctagcoder/parse/SSCC/ParseSSCC.java +++ b/epctagcoder/src/main/java/org/epctagcoder/parse/SSCC/ParseSSCC.java @@ -76,21 +76,16 @@ private void parse() { filterValue = SSCCFilterValue.forCode( Integer.parseInt(filterDec) ); tagSize = SSCCTagSize.forCode( SSCCHeader.forCode(headerBin).getTagSize() ); prefixLength = PrefixLength.forCode(tableItem.getL()); - System.out.println("***********************"); + } else { if ( optionalCompanyPrefix.isPresent() ) { SSCCPartitionTableList ssccPartitionTableList = new SSCCPartitionTableList(); prefixLength = PrefixLength.forCode( companyPrefix.length() ); - validateCompanyPrefix(); - tableItem = ssccPartitionTableList.getPartitionByL( prefixLength.getValue() ); - validateExtensionDigitAndSerial(); - } else { - if ( optionalEpcTagURI.isPresent() ) { Pattern pattern = Pattern.compile("(urn:epc:tag:sscc-)(96)\\:([0-7])\\.(\\d+)\\.([0-8])(\\d+)"); Matcher matcher = pattern.matcher(epcTagURI); @@ -122,8 +117,12 @@ private void parse() { } - SSCCPartitionTableList ssccPartitionTableList = new SSCCPartitionTableList(); - tableItem = ssccPartitionTableList.getPartitionByL( prefixLength.getValue() ); + if (prefixLength==null) { + throw new IllegalArgumentException("Invalid Prefix Length"); + } else { + SSCCPartitionTableList ssccPartitionTableList = new SSCCPartitionTableList(); + tableItem = ssccPartitionTableList.getPartitionByL( prefixLength.getValue() ); + } } diff --git a/epctagcoder/src/main/java/org/epctagcoder/result/Base.java b/epctagcoder/src/main/java/org/epctagcoder/result/Base.java index dadb198..9df15ef 100644 --- a/epctagcoder/src/main/java/org/epctagcoder/result/Base.java +++ b/epctagcoder/src/main/java/org/epctagcoder/result/Base.java @@ -13,6 +13,7 @@ public abstract class Base { private String epcRawURI; private String binary; private String rfidTag; + private String exception; public Base() { @@ -140,6 +141,16 @@ public void setRfidTag(String rfidTag) { } + public String getException() { + return exception; + } + + + public void setException(String exception) { + this.exception = exception; + } + +