isobasepackager.java

POS is a Java&#174 platform-based, mission-critical, ISO-8583 based financial transaction library/fr

                    evt.addMessage ("<bitmap>"+bmap.toString()+"</bitmap>");
                m.set (bitmap);
                maxField = Math.min(maxField, bmap.size());
            }
            for (int i=getFirstField(); i<maxField; i++) {
                try {
                    if (bmap == null && fld[i] == null)
                        continue;
                    if (maxField > 128 && i==65)
                        continue;   // ignore extended bitmap

                    if (bmap == null || bmap.get(i)) {
                        if (fld[i] == null)
                            throw new ISOException ("field packager '" + i + "' is null");

                        ISOComponent c = fld[i].createComponent(i);
                        consumed += fld[i].unpack (c, b, consumed);
                        if (logger != null) {
                            evt.addMessage ("<unpack fld=\"" + i 
                                +"\" packager=\""
                                +fld[i].getClass().getName()+ "\">");
                            if (c.getValue() instanceof ISOMsg)
                                evt.addMessage (c.getValue());
                            else if (c.getValue() instanceof byte[]) {
                                evt.addMessage ("  <value type='binary'>" 
                                    +ISOUtil.hexString((byte[]) c.getValue())
                                    + "</value>");
                            }
                            else {
                                evt.addMessage ("  <value>" 
                                    +c.getValue()
                                    + "</value>");
                            }
                            evt.addMessage ("</unpack>");
                        }
                        m.set(c);
                    }
                } catch (ISOException e) {
                    System.out.println("error unpacking field "+i);
                    e.printStackTrace(System.out);
                    evt.addMessage (e);
                    throw e;
                }
            }
            if (b.length != consumed) {
                evt.addMessage (
                    "WARNING: unpack len=" +b.length +" consumed=" +consumed
                );
            }
            return consumed;
        } catch (ISOException e) {
            evt.addMessage (e);
            throw e;
        } catch (Exception e) {
            e.printStackTrace();
            evt.addMessage (e);
            throw new ISOException (e);
        } finally {
            Logger.log (evt);
        }
    }
    public void unpack (ISOComponent m, InputStream in) 
        throws IOException, ISOException 
    {
        LogEvent evt = new LogEvent (this, "unpack");
        try {
            if (m.getComposite() != m) 
                throw new ISOException ("Can't call packager on non Composite");

            // if ISOMsg and headerLength defined 
            if (m instanceof ISOMsg && ((ISOMsg) m).getHeader()==null && headerLength>0) 
            {
            	byte[] h = new byte[headerLength];
            	in.read(h, 0, headerLength);
            	((ISOMsg) m).setHeader(h);
            }            
            
            
            if (!(fld[0] instanceof ISOMsgFieldPackager) &&
                !(fld[0] instanceof ISOBitMapPackager))
            {
                ISOComponent mti = fld[0].createComponent(0);
                fld[0].unpack(mti, in);
                m.set (mti);
            }
            BitSet bmap = null;
            int maxField = fld.length;
            if (emitBitMap()) {
                ISOBitMap bitmap = new ISOBitMap (-1);
                getBitMapfieldPackager().unpack(bitmap, in);
                bmap = (BitSet) bitmap.getValue();
                if (logger != null)
                    evt.addMessage ("<bitmap>"+bmap.toString()+"</bitmap>");
                m.set (bitmap);
                maxField = Math.min(maxField, bmap.size());
            }
                
            for (int i=getFirstField(); i<maxField; i++) {
                if (bmap == null && fld[i] == null)
                    continue;

                if (bmap == null || bmap.get(i)) {
                    if (fld[i] == null)
                        throw new ISOException ("field packager '" + i + "' is null");

                    ISOComponent c = fld[i].createComponent(i);
                    fld[i].unpack (c, in);
                    if (logger != null) {
                        evt.addMessage ("<unpack fld=\"" + i 
                            +"\" packager=\""
                            +fld[i].getClass().getName()+ "\">");
                        if (c.getValue() instanceof ISOMsg)
                            evt.addMessage (c.getValue());
                        else
                            evt.addMessage ("  <value>" 
                                +c.getValue().toString()
                                + "</value>");
                        evt.addMessage ("</unpack>");
                    }
                    m.set(c);
                }
            }
            if (bmap != null && bmap.get(65) && fld.length > 128 &&
                fld[65] instanceof ISOBitMapPackager)
            {
                bmap= (BitSet) 
                    ((ISOComponent) m.getChildren().get 
                        (new Integer(65))).getValue();
                for (int i=1; i<64; i++) {
                    if (bmap == null || bmap.get(i)) {
                        ISOComponent c = fld[i+128].createComponent(i);
                        fld[i+128].unpack (c, in);
                        if (logger != null) {
                            evt.addMessage ("<unpack fld=\"" + i+128
                                +"\" packager=\""
                                +fld[i+128].getClass().getName()+ "\">");
                            evt.addMessage ("  <value>" 
                                +c.getValue().toString()
                                + "</value>");
                            evt.addMessage ("</unpack>");
                        }
                        m.set(c);
                    }
                }
            }
        } catch (ISOException e) {
            evt.addMessage (e);
            throw e;
        } catch (EOFException e) {
            throw e;
        } catch (Exception e) {
            evt.addMessage (e);
            throw new ISOException (e);
        } finally {
            Logger.log (evt);
        }
    }
    /**
     * @param   m   the Container (i.e. an ISOMsg)
     * @param   fldNumber the Field Number
     * @return  Field Description
     */
    public String getFieldDescription(ISOComponent m, int fldNumber) {
        return fld[fldNumber].getDescription();
    }
    /**
     * @param   fldNumber the Field Number
     * @return  Field Packager for this field
     */
    public ISOFieldPackager getFieldPackager (int fldNumber) {
        return fld[fldNumber];
    }
    /**
     * @param   fldNumber the Field Number
     * @param   fieldPackager the Field Packager
     */
    public void setFieldPackager 
        (int fldNumber, ISOFieldPackager fieldPackager) 
    {
        fld[fldNumber] = fieldPackager;
    }
    public ISOMsg createISOMsg () {
        return new ISOMsg();
    }
    /**
     * @return 128 for ISO-8583, should return 64 for ANSI X9.2
     */
    protected int getMaxValidField() {
        return 128;
    }
    /**
     * @return suitable ISOFieldPackager for Bitmap
     */
    protected ISOFieldPackager getBitMapfieldPackager() {
        return fld[1];
    }
    public void setLogger (Logger logger, String realm) {
        this.logger = logger;
        this.realm  = realm;
    }
    public String getRealm () {
        return realm;
    }
    public Logger getLogger() {
        return logger;
    }
    public int getHeaderLength ()
    {
    	return headerLength;
    }
    public void setHeaderLength(int len)
    {
    	headerLength = len;
    }
}