Example usage for java.nio ByteBuffer order

List of usage examples for java.nio ByteBuffer order

Introduction

In this page you can find the example usage for java.nio ByteBuffer order.

Prototype

Endianness order

To view the source code for java.nio ByteBuffer order.

Click Source Link

Document

The byte order of this buffer, default is BIG_ENDIAN .

Usage

From source file:edu.harvard.iq.dvn.ingest.statdataio.impl.plugins.sav.SAVFileReader.java

void decodeRecordType1(BufferedInputStream stream) throws IOException {
    dbgLog.fine("***** decodeRecordType1(): start *****");

    if (stream == null) {
        throw new IllegalArgumentException("stream == null!");
    }//from  w  w w .  j  a v a2  s . c  om
    // how to read each recordType
    // 1. set-up the following objects before reading bytes
    // a. the working byte array
    // b. the storage object
    // the length of this field: 172bytes = 60 + 4 + 12 + 4 + 8 + 84
    // this field consists of 6 distinct blocks

    byte[] recordType1 = new byte[LENGTH_RECORDTYPE1];
    // int caseWeightVariableOBSIndex = 0; 

    try {
        int nbytes = stream.read(recordType1, 0, LENGTH_RECORDTYPE1);

        //printHexDump(recordType1, "recordType1");

        if (nbytes == 0) {
            throw new IOException("reading recordType1: no byte was read");
        }

        // 1.1 60 byte-String that tells the platform/version of SPSS that
        // wrote this file

        int offset_start = 0;
        int offset_end = LENGTH_SPSS_PRODUCT_INFO; // 60 bytes

        String productInfo = new String(Arrays.copyOfRange(recordType1, offset_start, offset_end), "US-ASCII");

        dbgLog.fine("productInfo:\n" + productInfo + "\n");

        // add the info to the fileInfo
        smd.getFileInformation().put("productInfo", productInfo);

        // try to parse out the SPSS version that created this data
        // file: 

        String spssVersionNumberTag = null;

        String regexpVersionNumber = ".*Release ([0-9]*)";
        Pattern patternJsession = Pattern.compile(regexpVersionNumber);
        Matcher matcher = patternJsession.matcher(productInfo);
        if (matcher.find()) {
            spssVersionNumberTag = matcher.group(1);
            dbgLog.fine("SPSS Version Number: " + spssVersionNumberTag);
        }

        if (spssVersionNumberTag != null && !spssVersionNumberTag.equals("")) {
            spssVersionNumber = Integer.valueOf(spssVersionNumberTag).intValue();

            /*
             *  Starting with SPSS version 16, the default encoding is 
             *  UTF-8. 
             *  But we are only going to use it if the user did not explicitly
             *  specify the encoding on the addfiles page. Then we'd want 
             *  to stick with whatever they entered. 
             */
            if (spssVersionNumber > 15) {
                if (getDataLanguageEncoding() == null) {
                    defaultCharSet = "UTF-8";
                }
            }
        }

        smd.getFileInformation().put("charset", defaultCharSet);

        // 1.2) 4-byte file-layout-code (byte-order)

        offset_start = offset_end;
        offset_end += LENGTH_FILE_LAYOUT_CODE; // 4 byte

        ByteBuffer bb_fileLayout_code = ByteBuffer.wrap(recordType1, offset_start, LENGTH_FILE_LAYOUT_CODE);

        ByteBuffer byteOderTest = bb_fileLayout_code.duplicate();
        // interprete the 4 byte as int

        int int2test = byteOderTest.getInt();

        if (int2test == 2 || int2test == 3) {
            dbgLog.fine("integer == " + int2test + ": the byte-oder of the writer is the same "
                    + "as the counterpart of Java: Big Endian");
        } else {
            // Because Java's byte-order is always big endian, 
            // this(!=2) means this sav file was  written on a little-endian machine
            // non-string, multi-bytes blocks must be byte-reversed

            bb_fileLayout_code.order(ByteOrder.LITTLE_ENDIAN);

            int2test = bb_fileLayout_code.getInt();

            if (int2test == 2 || int2test == 3) {
                dbgLog.fine("The sav file was saved on a little endian machine");
                dbgLog.fine("Reveral of the bytes is necessary to decode " + "multi-byte, non-string blocks");

                isLittleEndian = true;

            } else {
                throw new IOException("reading recordType1:unknown file layout code=" + int2test);
            }
        }

        dbgLog.fine("Endian of this platform:" + ByteOrder.nativeOrder().toString());

        smd.getFileInformation().put("OSByteOrder", ByteOrder.nativeOrder().toString());
        smd.getFileInformation().put("byteOrder", int2test);

        // 1.3 4-byte Number_Of_OBS_Units_Per_Case 
        // (= how many RT2 records => how many varilables)

        offset_start = offset_end;
        offset_end += LENGTH_NUMBER_OF_OBS_UNITS_PER_CASE; // 4 byte

        ByteBuffer bb_OBS_units_per_case = ByteBuffer.wrap(recordType1, offset_start,
                LENGTH_NUMBER_OF_OBS_UNITS_PER_CASE);

        if (isLittleEndian) {
            bb_OBS_units_per_case.order(ByteOrder.LITTLE_ENDIAN);
        }

        OBSUnitsPerCase = bb_OBS_units_per_case.getInt();

        dbgLog.fine("RT1: OBSUnitsPerCase=" + OBSUnitsPerCase);

        smd.getFileInformation().put("OBSUnitsPerCase", OBSUnitsPerCase);

        // 1.4 4-byte Compression_Switch

        offset_start = offset_end;
        offset_end += LENGTH_COMPRESSION_SWITCH; // 4 byte

        ByteBuffer bb_compression_switch = ByteBuffer.wrap(recordType1, offset_start,
                LENGTH_COMPRESSION_SWITCH);

        if (isLittleEndian) {
            bb_compression_switch.order(ByteOrder.LITTLE_ENDIAN);
        }

        int compression_switch = bb_compression_switch.getInt();
        if (compression_switch == 0) {
            // data section is not compressed
            isDataSectionCompressed = false;
            dbgLog.fine("data section is not compressed");
        } else {
            dbgLog.fine("data section is compressed:" + compression_switch);
        }

        smd.getFileInformation().put("compressedData", compression_switch);

        // 1.5 4-byte Case-Weight Variable Index
        // warning: this variable index starts from 1, not 0

        offset_start = offset_end;
        offset_end += LENGTH_CASE_WEIGHT_VARIABLE_INDEX; // 4 byte

        ByteBuffer bb_Case_Weight_Variable_Index = ByteBuffer.wrap(recordType1, offset_start,
                LENGTH_CASE_WEIGHT_VARIABLE_INDEX);

        if (isLittleEndian) {
            bb_Case_Weight_Variable_Index.order(ByteOrder.LITTLE_ENDIAN);
        }

        caseWeightVariableOBSIndex = bb_Case_Weight_Variable_Index.getInt();

        smd.getFileInformation().put("caseWeightVariableOBSIndex", caseWeightVariableOBSIndex);

        // 1.6 4-byte Number of Cases

        offset_start = offset_end;
        offset_end += LENGTH_NUMBER_OF_CASES; // 4 byte

        ByteBuffer bb_Number_Of_Cases = ByteBuffer.wrap(recordType1, offset_start, LENGTH_NUMBER_OF_CASES);

        if (isLittleEndian) {
            bb_Number_Of_Cases.order(ByteOrder.LITTLE_ENDIAN);
        }

        int numberOfCases = bb_Number_Of_Cases.getInt();

        if (numberOfCases < 0) {
            // -1 if numberOfCases is unknown
            throw new RuntimeException("number of cases is not recorded in the header");
        } else {
            dbgLog.fine("RT1: number of cases is recorded= " + numberOfCases);
            caseQnty = numberOfCases;
            smd.getFileInformation().put("caseQnty", numberOfCases);
        }

        // 1.7 8-byte compression-bias [not long but double]

        offset_start = offset_end;
        offset_end += LENGTH_COMPRESSION_BIAS; // 8 byte

        ByteBuffer bb_compression_bias = ByteBuffer
                .wrap(Arrays.copyOfRange(recordType1, offset_start, offset_end));

        if (isLittleEndian) {
            bb_compression_bias.order(ByteOrder.LITTLE_ENDIAN);
        }

        Double compressionBias = bb_compression_bias.getDouble();

        if (compressionBias == 100d) {
            // 100 is expected
            dbgLog.fine("compressionBias is 100 as expected");
            smd.getFileInformation().put("compressionBias", 100);
        } else {
            dbgLog.fine("compression bias is not 100: " + compressionBias);
            smd.getFileInformation().put("compressionBias", compressionBias);
        }

        // 1.8 84-byte File Creation Information (date/time: dd MM yyhh:mm:ss +
        // 64-bytelabel)

        offset_start = offset_end;
        offset_end += LENGTH_FILE_CREATION_INFO; // 84 bytes

        String fileCreationInfo = getNullStrippedString(
                new String(Arrays.copyOfRange(recordType1, offset_start, offset_end), "US-ASCII"));

        dbgLog.fine("fileCreationInfo:\n" + fileCreationInfo + "\n");

        String fileCreationDate = fileCreationInfo.substring(0, length_file_creation_date);
        int dateEnd = length_file_creation_date + length_file_creation_time;
        String fileCreationTime = fileCreationInfo.substring(length_file_creation_date, (dateEnd));
        String fileCreationNote = fileCreationInfo.substring(dateEnd, length_file_creation_label);

        dbgLog.fine("fileDate=" + fileCreationDate);
        dbgLog.fine("fileTime=" + fileCreationTime);
        dbgLog.fine("fileNote" + fileCreationNote);

        smd.getFileInformation().put("fileDate", fileCreationDate);
        smd.getFileInformation().put("fileTime", fileCreationTime);
        smd.getFileInformation().put("fileNote", fileCreationNote);
        smd.getFileInformation().put("varFormat_schema", "SPSS");

        // add the info to the fileInfo

        smd.getFileInformation().put("mimeType", MIME_TYPE[0]);
        smd.getFileInformation().put("fileFormat", MIME_TYPE[0]);

        smd.setValueLabelMappingTable(valueVariableMappingTable);

    } catch (IOException ex) {
        //ex.printStackTrace();
        throw ex;
    }

    dbgLog.fine("***** decodeRecordType1(): end *****");
}

From source file:org.energy_home.jemma.javagal.layers.data.implementations.IDataLayerImplementation.DataFreescale.java

public void processMessages() throws Exception {
    // Look on received messages
    int _size = 0;
    synchronized (this) {
        _size = messages.size();//from w w  w  . j  a  va 2s  . c  o  m
    }

    while (_size > 0) {
        short[] message = null;
        synchronized (this) {
            message = messages.remove(0);
        }

        ByteBuffer bb = ByteBuffer.allocate(2);
        bb.order(ByteOrder.BIG_ENDIAN);
        bb.put((byte) message[0]);
        bb.put((byte) message[1]);
        short _command = bb.getShort(0);

        /* APSDE-DATA.Indication */
        if (_command == FreescaleConstants.APSDEDataIndication) {
            final APSMessageEvent messageEvent = new APSMessageEvent();
            short destAddressMode = message[3];
            messageEvent.setDestinationAddressMode((long) destAddressMode);
            BigInteger _ieee = null;
            Address address = new Address();
            switch (destAddressMode) {
            case 0x00:
                // Reserved (No source address supplied)
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Message Discarded: found reserved 0x00 as Destination Address Mode ");
                } // Error found, we don't proceed and discard the
                  // message
                return;
            case 0x01:
                // Value16bitgroupfordstAddr (DstEndpoint not
                // present)
                // No destination end point (so FF broadcast),
                // present
                // short
                // address on 2 bytes
                address.setNetworkAddress(
                        DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));

                _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
                if (_ieee != null)
                    address.setIeeeAddress(_ieee);

                messageEvent.setDestinationAddress(address);
                messageEvent.setDestinationEndpoint((short) 0xff);

                break;
            case 0x02:
                // Value16bitAddrandDstEndpoint (16 bit address
                // supplied)
                address.setNetworkAddress(
                        DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
                _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
                if (_ieee != null)
                    address.setIeeeAddress(_ieee);

                messageEvent.setDestinationAddress(address);
                messageEvent.setDestinationEndpoint(message[6]);
                break;
            default:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.error("Message Discarded: not valid Destination Address Mode");
                }
                // Error found, we don't proceed and discard the
                // message
                return;
            }
            messageEvent.setSourceAddressMode((long) message[7]);
            address = new Address();
            address.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[9], (byte) message[8]));
            _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
            if (_ieee != null)
                address.setIeeeAddress(_ieee);
            messageEvent.setSourceAddress(address);
            messageEvent.setSourceEndpoint(message[10]);
            messageEvent.setProfileID(DataManipulation.toIntFromShort((byte) message[12], (byte) message[11]));
            messageEvent.setClusterID(DataManipulation.toIntFromShort((byte) message[14], (byte) message[13]));

            if (gal.getGatewayStatus() == GatewayStatus.GW_RUNNING && gal.get_GalNode() != null) {
                /* Update The Node Data */

                int _indexOnCache = -1;
                _indexOnCache = gal.existIntoNetworkCache(address.getNetworkAddress());
                if (_indexOnCache != -1) {
                    /* The node is already into the DB */
                    if (gal.getPropertiesManager().getKeepAliveThreshold() > 0) {
                        if (!gal.getNetworkcache().get(_indexOnCache).isSleepy()) {
                            gal.getNetworkcache().get(_indexOnCache).reset_numberOfAttempt();
                            gal.getNetworkcache().get(_indexOnCache)
                                    .setTimerFreshness(gal.getPropertiesManager().getKeepAliveThreshold());
                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                //System.out.println("\n\rPostponing  timer Freshness by Aps.Indication for node:" + gal.getNetworkcache().get(_indexOnCache).get_node().getAddress().getNetworkAddress() + "\n\r");
                                logger.info("Postponing  timer Freshness by Aps.Indication for node:"
                                        + gal.getNetworkcache().get(_indexOnCache).get_node().getAddress()
                                                .getNetworkAddress());
                            }
                        }

                    }
                } else {
                    // 0x8034 is a LeaveAnnouncement, 0x0013 is a
                    // DeviceAnnouncement, 0x8001 is a IEEE_Addr_Rsp
                    if ((gal.getPropertiesManager().getAutoDiscoveryUnknownNodes() > 0)
                            && (!(messageEvent.getProfileID() == 0x0000
                                    && (messageEvent.getClusterID() == 0x0013
                                            || messageEvent.getClusterID() == 0x8034
                                            || messageEvent.getClusterID() == 0x8001)))) {

                        if (address.getNetworkAddress() != gal.get_GalNode().get_node().getAddress()
                                .getNetworkAddress()) {
                            Runnable thr = new MyThread(address) {
                                @Override
                                public void run() {
                                    Address _address = (Address) this.getParameter();
                                    int _indexOnCache = -1;
                                    _indexOnCache = gal.existIntoNetworkCache(_address.getNetworkAddress());
                                    if (_indexOnCache == -1) {

                                        if (gal.getPropertiesManager().getDebugEnabled()) {
                                            //System.out.println("\n\rAutoDiscoveryUnknownNodes procedure of Node:" + messageEvent.getSourceAddress().getNetworkAddress() + "\n\r");

                                            logger.info("AutoDiscoveryUnknownNodes procedure of Node:"
                                                    + messageEvent.getSourceAddress().getNetworkAddress());
                                        }
                                        try {

                                            // Insert the node into cache,
                                            // but with the
                                            // discovery_completed flag a
                                            // false
                                            BigInteger ieee = null;
                                            WrapperWSNNode o = new WrapperWSNNode(gal);
                                            WSNNode _newNode = new WSNNode();
                                            o.set_discoveryCompleted(false);
                                            _newNode.setAddress(_address);
                                            o.set_node(_newNode);
                                            gal.getNetworkcache().add(o);

                                            Thread.sleep(500);
                                            /*
                                             * Reading the IEEEAddress of
                                             * the new node
                                             */

                                            if (gal.getPropertiesManager().getDebugEnabled())
                                                logger.info(
                                                        "Sending IeeeReq to:" + _address.getNetworkAddress());
                                            System.out.println(
                                                    "Sending IeeeReq to:" + _address.getNetworkAddress());
                                            ieee = readExtAddress(INTERNAL_TIMEOUT,
                                                    _address.getNetworkAddress().shortValue());
                                            _address.setIeeeAddress(ieee);
                                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                                logger.info("Readed Ieee of the new node:"
                                                        + _address.getNetworkAddress() + " Ieee: "
                                                        + ieee.toString());
                                                System.out.println("Readed Ieee of the new node:"
                                                        + _address.getNetworkAddress() + " Ieee: "
                                                        + ieee.toString());

                                            }
                                            if (gal.getPropertiesManager().getDebugEnabled())
                                                logger.info("Sending NodeDescriptorReq to:"
                                                        + _address.getNetworkAddress());
                                            NodeDescriptor _ndesc = getNodeDescriptorSync(INTERNAL_TIMEOUT,
                                                    _address);
                                            _newNode.setCapabilityInformation(_ndesc.getMACCapabilityFlag());

                                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                                logger.info("Readed NodeDescriptor of the new node:"
                                                        + _address.getNetworkAddress());
                                                System.out.println("Readed NodeDescriptor of the new node:"
                                                        + _address.getNetworkAddress());

                                            }

                                            o.reset_numberOfAttempt();
                                            o.set_discoveryCompleted(true);
                                            if (!o.isSleepy()) {

                                                if (gal.getPropertiesManager().getKeepAliveThreshold() > 0) {
                                                    o.setTimerFreshness(
                                                            gal.getPropertiesManager().getKeepAliveThreshold());
                                                }
                                                if (gal.getPropertiesManager().getForcePingTimeout() > 0) {
                                                    o.setTimerForcePing(
                                                            gal.getPropertiesManager().getForcePingTimeout());
                                                }
                                            }

                                            _indexOnCache = gal.existIntoNetworkCache(
                                                    _newNode.getAddress().getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().remove(_indexOnCache);

                                            }

                                            // Updating the node
                                            // informations
                                            gal.getNetworkcache().add(o);
                                            o.set_discoveryCompleted(true);
                                            Status _st = new Status();
                                            _st.setCode((short) GatewayConstants.SUCCESS);
                                            gal.get_gatewayEventManager().nodeDiscovered(_st, _newNode);

                                        } catch (GatewayException e) {
                                            logger.error("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());

                                            System.out.println("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());

                                            _indexOnCache = gal
                                                    .existIntoNetworkCache(_address.getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().get(_indexOnCache).abortTimers();
                                                gal.getNetworkcache().remove(_indexOnCache);
                                            }

                                        } catch (Exception e) {
                                            logger.error("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());
                                            System.out.println("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());
                                            _indexOnCache = gal
                                                    .existIntoNetworkCache(_address.getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().get(_indexOnCache).abortTimers();
                                                gal.getNetworkcache().remove(_indexOnCache);

                                            }

                                        }
                                    }
                                }
                            };

                            Thread _thr0 = new Thread(thr);
                            _thr0.setName("Thread getAutoDiscoveryUnknownNodes:" + address.getNetworkAddress());
                            _thr0.start();
                        }
                    }
                }

            }
            int lastAsdu = 16 + message[15] - 1;

            messageEvent.setData(DataManipulation.subByteArray(message, 16, lastAsdu));
            messageEvent.setAPSStatus(message[lastAsdu + 1]);
            // ASK Jump WasBroadcast
            // Security Status
            switch (message[lastAsdu + 3]) {
            case 0x00:
                messageEvent.setSecurityStatus(SecurityStatus.UNSECURED);
                break;
            case 0x01:
                messageEvent.setSecurityStatus(SecurityStatus.SECURED_NWK_KEY);
                break;
            case 0x02:
                messageEvent.setSecurityStatus(SecurityStatus.SECURED_LINK_KEY);
                break;
            // ASK 0x03 not present on telecomitalia object
            default:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Message Discarded: not valid Security Status");
                }
                // Error found, we don't proceed and discard the
                // message
                return;
            }
            messageEvent.setLinkQuality(message[lastAsdu + 4]);
            messageEvent.setRxTime((long) DataManipulation.toIntFromShort((byte) message[(lastAsdu + 8)],
                    (byte) message[(lastAsdu + 5)]));
            // ASK: jumped iMsgType, pNext, iDataSize, pData,
            // iBufferNumber
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSDE-DATA.Indication", message);
            if ((messageEvent.getDestinationAddressMode() == GatewayConstants.ADDRESS_MODE_SHORT)
                    && (messageEvent.getDestinationAddress().getIeeeAddress() == null))
                messageEvent.getDestinationAddress().setIeeeAddress(gal.getIeeeAddress_FromNetworkCache(
                        messageEvent.getDestinationAddress().getNetworkAddress()));

            if ((messageEvent.getDestinationAddressMode() == GatewayConstants.EXTENDED_ADDRESS_MODE)
                    && (messageEvent.getDestinationAddress().getNetworkAddress() == null))
                messageEvent.getDestinationAddress().setNetworkAddress(gal.getShortAddress_FromNetworkCache(
                        messageEvent.getDestinationAddress().getIeeeAddress()));

            if ((messageEvent.getSourceAddressMode() == GatewayConstants.ADDRESS_MODE_SHORT)
                    && (messageEvent.getDestinationAddress().getIeeeAddress() == null))
                messageEvent.getSourceAddress().setIeeeAddress(gal
                        .getIeeeAddress_FromNetworkCache(messageEvent.getSourceAddress().getNetworkAddress()));

            if ((messageEvent.getSourceAddressMode() == GatewayConstants.EXTENDED_ADDRESS_MODE)
                    && (messageEvent.getDestinationAddress().getNetworkAddress() == null))
                messageEvent.getSourceAddress().setNetworkAddress(
                        gal.getShortAddress_FromNetworkCache(messageEvent.getSourceAddress().getIeeeAddress()));

            if (messageEvent.getProfileID().equals(0)) {/*
                                                        * ZDO Command
                                                        */
                if (messageEvent.getClusterID() == 0x8031) {
                    String __key = "";
                    __key = String.format("%04X", messageEvent.getSourceAddress().getNetworkAddress());
                    synchronized (listLocker) {
                        for (ParserLocker pl : listLocker) {
                            if ((pl.getType() == TypeMessage.LQI_REQ) && __key.equalsIgnoreCase(pl.get_Key())) {
                                synchronized (pl) {
                                    pl.getStatus().setCode((short) messageEvent.getAPSStatus());
                                    Mgmt_LQI_rsp _res = new Mgmt_LQI_rsp(messageEvent.getData());
                                    pl.set_objectOfResponse(_res);
                                    pl.notify();
                                }
                                break;
                            }
                        }
                    }
                }
                // profileid == 0
                gal.getZdoManager().ZDOMessageIndication(messageEvent);
            } else {
                // profileid > 0
                ZCLMessage _zm = new ZCLMessage();
                _zm.setAPSStatus(messageEvent.getAPSStatus());
                _zm.setClusterID(messageEvent.getClusterID());
                _zm.setDestinationEndpoint(messageEvent.getDestinationEndpoint());
                _zm.setProfileID(messageEvent.getProfileID());
                _zm.setRxTime(messageEvent.getRxTime());
                _zm.setSourceAddress(messageEvent.getSourceAddress());
                _zm.setSourceAddressMode(messageEvent.getSourceAddressMode());
                _zm.setSourceEndpoint(messageEvent.getSourceEndpoint());

                byte[] data = messageEvent.getData();
                // ZCL Header
                // Frame control 8bit
                // Manufacturer code 0/16bits
                // Transaction sequence number 8bit
                // Command identifier 8 bit
                ByteArrayObject _header = new ByteArrayObject();
                ByteArrayObject _payload = new ByteArrayObject();
                if ((data[0] & 0x04) == 1)/* Check manufacturer code */
                {
                    _header.addByte(data[0]);// Frame control
                    _header.addByte(data[1]);// Manufacturer Code(1/2)
                    _header.addByte(data[2]);// Manufacturer Code(2/2)
                    _header.addByte(data[3]);// Transaction sequence number
                    _header.addByte(data[4]);// Command Identifier
                    for (int i = 5; i < data.length; i++)
                        _payload.addByte(data[i]);
                } else {
                    _header.addByte(data[0]);// Frame control
                    _header.addByte(data[1]);// Transaction sequence number
                    _header.addByte(data[2]);// Command Identifier
                    for (int i = 3; i < data.length; i++)
                        _payload.addByte(data[i]);
                }

                _zm.setZCLHeader(_header.getRealByteArray());
                _zm.setZCLPayload(_payload.getRealByteArray());
                gal.get_gatewayEventManager().notifyZCLCommand(_zm);
                gal.getApsManager().APSMessageIndication(messageEvent);

            }
        }

        /* APSDE-DATA.Confirm */
        else if (_command == FreescaleConstants.APSDEDataConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSDE-DATA.Confirm", message);

            /* DestAddress + DestEndPoint + SourceEndPoint */
            long destAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            byte destEndPoint = (byte) message[12];
            byte sourceEndPoint = (byte) message[13];
            String Key = String.format("%016X", destAddress) + String.format("%02X", destEndPoint)
                    + String.format("%02X", sourceEndPoint);

            // Found APSDE-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* DestAddress + DestEndPoint + SourceEndPoint */
                    /*
                     * if (gal.getPropertiesManager().getDebugEnabled())
                     * logger.info("APSDE-DATA.Confirm KEY SEND: " +
                     * pl.get_Key() + " -- KEY Received: " + Key);
                     */
                    if ((pl.getType() == TypeMessage.APS) && pl.get_Key().equalsIgnoreCase(Key)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[14]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* ZTC-Error.event */
        else if (_command == FreescaleConstants.ZTCErrorevent) {

            byte len = (byte) message[2];
            String MessageStatus = "";
            if (len > 0) {
                int status = message[3];
                switch (status) {
                case 0x00:
                    MessageStatus = "0x00: gSuccess_c (Should not be seen in this event.)";
                    break;
                case 0xF4:
                    MessageStatus = "0xF4: gZtcOutOfMessages_c (ZTC tried to allocate a message, but the allocation failed.)";
                    break;
                case 0xF5:
                    MessageStatus = "0xF5: gZtcEndPointTableIsFull_c (Self explanatory.)";
                    break;
                case 0xF6:
                    MessageStatus = "0xF6: gZtcEndPointNotFound_c (Self explanatory.)";
                    break;
                case 0xF7:
                    MessageStatus = "0xF7: gZtcUnknownOpcodeGroup_c (ZTC does not recognize the opcode group, and there is no application hook.)";
                    break;
                case 0xF8:
                    MessageStatus = "0xF8: gZtcOpcodeGroupIsDisabled_c (ZTC support for an opcode group is turned off by a compile option.)";
                    break;
                case 0xF9:
                    MessageStatus = "0xF9: gZtcDebugPrintFailed_c (An attempt to print a debug message ran out of buffer space.)";
                    break;
                case 0xFA:
                    MessageStatus = "0xFA: gZtcReadOnly_c (Attempt to set read-only data.)";
                    break;
                case 0xFB:
                    MessageStatus = "0xFB: gZtcUnknownIBIdentifier_c (Self explanatory.)";
                    break;
                case 0xFC:
                    MessageStatus = "0xFC: gZtcRequestIsDisabled_c (ZTC support for an opcode is turned off by a compile option.)";
                    break;
                case 0xFD:
                    MessageStatus = "0xFD: gZtcUnknownOpcode_c (Self expanatory.)";
                    break;
                case 0xFE:
                    MessageStatus = "0xFE: gZtcTooBig_c (A data item to be set or retrieved is too big for the buffer available to hold it.)";
                    break;
                case 0xFF:
                    MessageStatus = "0xFF: gZtcError_c (Non-specific, catchall error code.)";
                    break;
                default:
                    break;
                }

            }
            String logMessage = "Extracted ZTC-ERROR.Event Status:" + MessageStatus;
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix(logMessage, message);
        }

        /* ZDP-Mgmt_Nwk_Update.Notify */

        else if (_command == FreescaleConstants.ZDPMgmt_Nwk_UpdateNotify) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Nwk_Update.Notify", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NWK_UPDATE) {

                        EnergyScanResult _result = new EnergyScanResult();

                        int _address = DataManipulation.toIntFromShort((byte) message[4], (byte) message[3]);

                        short _status = message[5];
                        if (_status == GatewayConstants.SUCCESS) {
                            byte[] _scannedChannel = new byte[4];
                            _scannedChannel[0] = (byte) message[9];
                            _scannedChannel[1] = (byte) message[8];
                            _scannedChannel[2] = (byte) message[7];
                            _scannedChannel[3] = (byte) message[6];

                            int _totalTrasmission = DataManipulation.toIntFromShort((byte) message[11],
                                    (byte) message[10]);

                            int _trasmissionFailure = DataManipulation.toIntFromShort((byte) message[13],
                                    (byte) message[12]);

                            short _scannedChannelListCount = message[14];
                            for (int i = 0; i < _scannedChannelListCount; i++) {
                                ScannedChannel _sc = new ScannedChannel();
                                // _sc.setChannel(value)
                                _sc.setEnergy(message[15 + i]);

                                _result.getScannedChannel().add(_sc);
                            }
                            synchronized (pl) {
                                pl.getStatus().setCode(message[7]);
                                pl.set_objectOfResponse(_result);
                                pl.notify();
                            }
                            break;

                        }

                    }
                }
            }

        }

        /* ZDP-SimpleDescriptor.Response */
        else if (_command == FreescaleConstants.ZDPSimpleDescriptorResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-ExtendedSimpleDescriptor.Response", message);
            /* Address + EndPoint */
            Address _add = new Address();

            _add.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
            byte EndPoint = (byte) message[7];
            String Key = String.format("%04X", _add.getNetworkAddress()) + String.format("%02X", EndPoint);
            // Found ZDP-SimpleDescriptor.Response. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* Address + EndPoint */
                    if ((pl.getType() == TypeMessage.GET_SIMPLE_DESCRIPTOR)
                            && pl.get_Key().equalsIgnoreCase(Key)) {

                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {

                                SimpleDescriptor _sp = new SimpleDescriptor();
                                _sp.setApplicationProfileIdentifier(
                                        DataManipulation.toIntFromShort((byte) message[9], (byte) message[8]));
                                _sp.setApplicationDeviceIdentifier(DataManipulation
                                        .toIntFromShort((byte) message[11], (byte) message[10]));
                                _sp.setApplicationDeviceVersion(message[12]);
                                int _index = 14;
                                short _numInpCluster = message[13];
                                for (int i = 0; i < _numInpCluster; i++) {
                                    _sp.getApplicationInputCluster().add(DataManipulation.toIntFromShort(
                                            (byte) message[_index + 1], (byte) message[_index]));
                                    _index = _index + 2;
                                }

                                short _numOutCluster = message[_index++];

                                for (int i = 0; i < _numOutCluster; i++) {
                                    _sp.getApplicationOutputCluster().add(DataManipulation.toIntFromShort(
                                            (byte) message[_index + 1], (byte) message[_index]));
                                    _index = _index + 2;
                                }
                                ServiceDescriptor _toRes = new ServiceDescriptor();
                                _toRes.setAddress(_add);
                                _toRes.setEndPoint(EndPoint);
                                _toRes.setSimpleDescriptor(_sp);
                                pl.set_objectOfResponse(_toRes);
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* APS-GetEndPointIdList.Confirm */
        else if (_command == FreescaleConstants.APSGetEndPointIdListConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-GetEndPointIdList.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.GET_END_POINT_LIST)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            NodeServices _res = new NodeServices();
                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {
                                short length = message[4];
                                for (int i = 0; i < length; i++) {
                                    ActiveEndpoints _ep = new ActiveEndpoints();
                                    _ep.setEndPoint(message[5 + i]);
                                    _res.getActiveEndpoints().add(_ep);
                                }
                            }
                            pl.set_objectOfResponse(_res);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-BIND.Response */
        else if (_command == FreescaleConstants.ZDPMgmtBindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-BIND.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.ADD_BINDING)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            switch (pl.getStatus().getCode()) {
                            case GatewayConstants.SUCCESS:

                                break;

                            case 0x84:
                                pl.getStatus().setMessage("NOT_SUPPORTED (NOT SUPPORTED)");
                                break;

                            case 0x8C:
                                pl.getStatus().setMessage("TABLE_FULL (TABLE FULL)");
                                break;
                            case 0x8D:
                                pl.getStatus().setMessage("NOT_AUTHORIZED (NOT AUTHORIZED)");
                                break;
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-UNBIND.Response */
        else if (_command == FreescaleConstants.ZDPUnbindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-UNBIND.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.REMOVE_BINDING)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            switch (pl.getStatus().getCode()) {
                            case GatewayConstants.SUCCESS:

                                break;

                            case 0x84:
                                pl.getStatus().setMessage("NOT_SUPPORTED (NOT SUPPORTED)");
                                break;
                            case 0x88:
                                pl.getStatus().setMessage("No_Entry (No Entry)");
                                break;
                            case 0x8D:
                                pl.getStatus().setMessage("NOT_AUTHORIZED (NOT AUTHORIZED");
                                break;
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-Mgmt_Bind.Response */
        else if (_command == FreescaleConstants.ZDPMgmt_BindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Bind.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.GET_BINDINGS)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            BindingList _res = new BindingList();

                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {
                                short length = message[6];
                                int _index = 6;
                                for (int i = 0; i < length; i++) {
                                    Binding _b = new Binding();
                                    long src_longAddress = DataManipulation.toLong((byte) message[_index + 8],
                                            (byte) message[_index + 7], (byte) message[_index + 6],
                                            (byte) message[_index + 5], (byte) message[_index + 4],
                                            (byte) message[_index + 3], (byte) message[_index + 2],
                                            (byte) message[_index + 1]);
                                    short _srcEP = message[_index + 9];

                                    int _cluster = DataManipulation.toIntFromShort((byte) message[_index + 11],
                                            (byte) message[_index + 10]);

                                    short _DestinationMode = message[_index + 12];
                                    Device _dev = new Device();

                                    if (_DestinationMode == 0x03) {

                                        long dst_longAddress = DataManipulation.toLong(
                                                (byte) message[_index + 20], (byte) message[_index + 19],
                                                (byte) message[_index + 18], (byte) message[_index + 17],
                                                (byte) message[_index + 16], (byte) message[_index + 15],
                                                (byte) message[_index + 14], (byte) message[_index + 13]);

                                        short _dstEP = message[_index + 21];
                                        _dev.setAddress(BigInteger.valueOf(dst_longAddress));
                                        _dev.setEndpoint(_dstEP);
                                        _index = _index + 21;
                                    } else if (_DestinationMode == 0x01) {

                                        int _groupId = DataManipulation.toIntFromShort(
                                                (byte) message[_index + 14], (byte) message[_index + 13]);
                                        _dev.setAddress(BigInteger.valueOf(_groupId));
                                        _index = _index + 10;
                                    }
                                    _b.setClusterID(_cluster);
                                    _b.setSourceEndpoint(_srcEP);
                                    _b.setSourceIEEEAddress(BigInteger.valueOf(src_longAddress));

                                    _b.getDeviceDestination().add(_dev);
                                    _res.getBinding().add(_b);

                                }
                            }
                            pl.set_objectOfResponse(_res);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* APS-DeregisterEndPoint.Confirm */
        else if (_command == FreescaleConstants.APSDeRegisterEndPointConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-DeregisterEndPoint.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.DEREGISTER_END_POINT)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* APS-ZDP-Mgmt_Lqi.Response */
        else if (_command == FreescaleConstants.ZDPMgmtLqiResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix(
                        "Extracted ZDP-Mgmt_Lqi.Response... waiting the related Indication ZDO", message);

        }
        /* ZTC-ReadExtAddr.Confirm */
        else if (_command == FreescaleConstants.ZTCReadExtAddrConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-ReadExtAddr.Confirm", message);
            long longAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            BigInteger _bi = BigInteger.valueOf(longAddress);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.READ_EXT_ADDRESS)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_bi);
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* ZDP-IEEE_addr.response */
        else if (_command == FreescaleConstants.ZDPIeeeAddrResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-IEEE_addr.response", message);
            long longAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            BigInteger _bi = BigInteger.valueOf(longAddress);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.READ_IEEE_ADDRESS)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_bi);
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* ZDP-Mgmt_Leave.Response */
        else if (_command == FreescaleConstants.ZDPMgmtLeaveResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Leave.Response", message);

        }
        /* ZDP-Active_EP_rsp.response */
        else if (_command == FreescaleConstants.ZDPActiveEpResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Active_EP_rsp.response", message);
            short Status = message[3];
            Address _add = new Address();

            _add.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
            String Key = String.format("%04X", _add.getNetworkAddress());
            List<Short> _toRes = null;

            NodeServices _node = new NodeServices();
            _node.setAddress(_add);

            switch (Status) {
            case 0x00:
                _toRes = new ArrayList<Short>();
                int _EPCount = message[6];

                for (int i = 0; i < _EPCount; i++) {
                    _toRes.add(message[7 + i]);
                    ActiveEndpoints _aep = new ActiveEndpoints();
                    _aep.setEndPoint(message[7 + i]);
                    _node.getActiveEndpoints().add(_aep);

                }
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:00 - Success");
                }
                break;
            case 0x80:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:80 - Inv_RequestType");
                }
                break;
            case 0x89:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:89 - No_Descriptor");
                }
                break;
            case 0x81:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:81 - Device_Not_found");
                }
                break;
            }
            // Found ZDP-Active_EP_rsp.response. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* DestAddress */
                    if ((pl.getType() == TypeMessage.ACTIVE_EP) && pl.get_Key().equalsIgnoreCase(Key)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_toRes);
                            pl.getStatus().setCode(Status);
                            pl.notify();

                        }
                        break;
                    }
                }
            }

        }

        /* ZDP-StopNwkEx.Confirm */
        else if (_command == FreescaleConstants.ZTCStopNwkExConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-StopNwkEx.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.STOP_NETWORK) {
                        if (message[3] == 0x00) {
                            gal.get_gatewayEventManager().notifyGatewayStopResult(makeStatusObject(
                                    "The stop command has been processed byt ZDO with success.", (short) 0x00));
                            synchronized (gal) {
                                gal.setGatewayStatus(GatewayStatus.GW_STOPPING);
                            }
                        }
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* NLME-GET.Confirm */
        else if (_command == FreescaleConstants.NLMEGetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-GET.Confirm", message);
            String _Key = String.format("%02X", message[4]);
            // Found APSDE-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NMLE_GET && pl.get_Key().equalsIgnoreCase(_Key)) {
                        short _Length = (short) DataManipulation.toIntFromShort((byte) message[9],
                                (byte) message[8]);
                        byte[] _res = DataManipulation.subByteArray(message, 10, _Length + 9);
                        if (_Length >= 2)
                            _res = DataManipulation.reverseBytes(_res);
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(DataManipulation.convertBytesToString(_res));
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* APSME_GET.Confirm */
        else if (_command == FreescaleConstants.APSMEGetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSME_GET.Confirm", message);
            String _Key = String.format("%02X", message[4]);
            // Found APSME_GET-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.APSME_GET && pl.get_Key().equalsIgnoreCase(_Key)) {
                        short _Length = (short) DataManipulation.toIntFromShort((byte) message[9],
                                (byte) message[8]);
                        byte[] _res = DataManipulation.subByteArray(message, 10, _Length + 9);
                        if (_Length >= 2)
                            _res = DataManipulation.reverseBytes(_res);
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(DataManipulation.convertBytesToString(_res));
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        // ZDP-StartNwkEx.Confirm
        else if (_command == FreescaleConstants.ZTCStartNwkExConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-StartNwkEx.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.START_NETWORK) {
                        if (message[3] == 0x00) {
                            gal.setGatewayStatus(GatewayStatus.GW_STARTED);
                        }
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* APS-RegisterEndPoint.Confirm */
        else if (_command == FreescaleConstants.APSRegisterEndPointConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-RegisterEndPoint.Confirm", message);
            // Found APS-RegisterEndPoint.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CONFIGURE_END_POINT) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* ZTC-ModeSelect.Confirm */
        else if (_command == FreescaleConstants.ZTCModeSelectConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-ModeSelect.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.MODE_SELECT) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* MacGetPIBAttribute.Confirm */
        else if (_command == FreescaleConstants.MacGetPIBAttributeConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacGetPIBAttribute.Confirm", message);
        }
        /* MacBeaconNotify.Indication */
        else if (_command == FreescaleConstants.MacBeaconNotifyIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacBeaconNotify.Indication", message);
        }
        /* MacBeaconStart.Indication */
        else if (_command == FreescaleConstants.MacPollNotifyIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacBeaconStart.Indication", message);
        }
        /* NLME-NETWORK-FORMATION.Confirmn */
        else if (_command == FreescaleConstants.NLMENETWORKFORMATIONConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Confirm", message);
        }
        /* NLME-START-ROUTER.Request */
        else if (_command == FreescaleConstants.NLMESTARTROUTERRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Confirm", message);
        }
        /* MacStart.Request */
        else if (_command == FreescaleConstants.MacStartRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacStart.Request", message);
        }
        /* MacStart.Confirm */
        else if (_command == FreescaleConstants.MacStartConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacStart.Confirm", message);
        }
        /* NLME-START-ROUTER.Confirm */
        else if (_command == FreescaleConstants.NLMESTARTROUTERConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-START-ROUTER.Confirm", message);
        }
        /* NWK-ProcessSecureFrame.Report */
        else if (_command == FreescaleConstants.NWKProcessSecureFrameReport) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NWK-ProcessSecureFrame.Report", message);
        }
        /* ZDP-Nwk-ProcessSecureFrame.Confirm */
        else if (_command == FreescaleConstants.ZDPNwkProcessSecureFrameConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Nwk-ProcessSecureFrame.Confirm", message);
        }

        /* BlackBox.WriteSAS.Confirm */
        else if (_command == FreescaleConstants.BlackBoxWriteSASConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted BlackBox.WriteSAS.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.WRITE_SAS) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* ZTC-GetChannel.Confirm */
        else if (_command == FreescaleConstants.ZTCGetChannelConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-GetChannel.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CHANNEL_REQUEST) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(message[4]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-NodeDescriptor.Response */
        else if (_command == FreescaleConstants.ZDPNodeDescriptorResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-NodeDescriptor.Response", message);
            int _NWKAddressOfInterest = DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]);
            Address _addressOfInterst = new Address();
            _addressOfInterst.setNetworkAddress(_NWKAddressOfInterest);
            NodeDescriptor _node = new NodeDescriptor();

            /* First Byte */
            byte _first = (byte) message[6];
            byte _Logical_byte = (byte) (_first & 0x07);/* Bits 0,1,2 */
            byte _ComplexDescriptorAvalilable = (byte) ((_first & 0x08) >> 3);/* Bit3 */
            byte _UserDescriptorAvalilable = (byte) ((_first & 0x0A) >> 4);/* Bit4 */
            switch (_Logical_byte) {
            case FreescaleConstants.LogicalType.Coordinator:
                _node.setLogicalType(LogicalType.COORDINATOR);
                break;
            case FreescaleConstants.LogicalType.Router:
                _node.setLogicalType(LogicalType.ROUTER);
                break;
            case FreescaleConstants.LogicalType.EndDevice:
                _node.setLogicalType(LogicalType.END_DEVICE);
                break;
            default:
                throw new Exception("LogicalType is not valid value");
            }
            _node.setComplexDescriptorAvailable((_ComplexDescriptorAvalilable == 1 ? true : false));
            _node.setUserDescriptorAvailable((_UserDescriptorAvalilable == 1 ? true : false));

            /* Second Byte */
            byte _second = (byte) message[7];
            /* Aps flags bits 0,1,2 */
            byte _FrequencyBand = (byte) ((_second & 0xF8) >> 0x03);/*
                                                                    * bits
                                                                    * 3
                                                                    * ,4,5,
                                                                    * 6,7
                                                                    */
            switch (_FrequencyBand) {
            case 0x01:
                _node.setFrequencyBand("868MHz");
                break;
            case 0x04:
                _node.setFrequencyBand("900MHz");
                break;
            case 0x08:
                _node.setFrequencyBand("2400MHz");
                break;
            default:
                _node.setFrequencyBand("Reserved");
                break;
            }

            /* MACcapabilityFlags_BYTE Byte */
            byte _MACcapabilityFlags_BYTE = (byte) message[8];
            MACCapability _maccapability = new MACCapability();
            byte _AlternatePanCoordinator = (byte) (_MACcapabilityFlags_BYTE & 0x01);/* Bit0 */
            byte _DeviceIsFFD = (byte) ((_MACcapabilityFlags_BYTE & 0x02) >> 1);/* Bit1 */
            byte _MainsPowered = (byte) ((_MACcapabilityFlags_BYTE & 0x04) >> 2);/* Bit2 */
            byte _ReceiverOnWhenIdle = (byte) ((_MACcapabilityFlags_BYTE & 0x08) >> 3);/* Bit3 */
            // bit 4-5 reserved
            byte _SecuritySupported = (byte) ((_MACcapabilityFlags_BYTE & 0x40) >> 6);/* Bit6 */
            byte _AllocateAddress = (byte) ((_MACcapabilityFlags_BYTE & 0x80) >> 7);/* Bit7 */
            _maccapability.setAlternatePanCoordinator((_AlternatePanCoordinator == 1 ? true : false));
            _maccapability.setDeviceIsFFD((_DeviceIsFFD == 1 ? true : false));
            _maccapability.setMainsPowered((_MainsPowered == 1 ? true : false));
            _maccapability.setReceiverOnWhenIdle((_ReceiverOnWhenIdle == 1 ? true : false));
            _maccapability.setSecuritySupported((_SecuritySupported == 1 ? true : false));
            _maccapability.setAllocateAddress((_AllocateAddress == 1 ? true : false));
            _node.setMACCapabilityFlag(_maccapability);

            /* ManufacturerCode_BYTES */
            int _ManufacturerCode_BYTES = DataManipulation.toIntFromShort((byte) message[10],
                    (byte) message[9]);
            _node.setManufacturerCode(_ManufacturerCode_BYTES);

            /* MaximumBufferSize_BYTE */
            short _MaximumBufferSize_BYTE = message[11];
            _node.setMaximumBufferSize(_MaximumBufferSize_BYTE);

            /* MaximumTransferSize_BYTES */
            int _MaximumTransferSize_BYTES = DataManipulation.toIntFromShort((byte) message[13],
                    (byte) message[12]);
            _node.setMaximumIncomingTransferSize(_MaximumTransferSize_BYTES);

            /* ServerMask_BYTES */
            int _ServerMask_BYTES = DataManipulation.toIntFromShort((byte) message[15], (byte) message[14]);
            ServerMask _serverMask = new ServerMask();
            byte _PrimaryTrustCenter = (byte) (_ServerMask_BYTES & 0x01);/* Bit0 */
            byte _BackupTrustCenter = (byte) ((_ServerMask_BYTES & 0x02) >> 1);/* Bit1 */
            byte _PrimaryBindingTableCache = (byte) ((_ServerMask_BYTES & 0x04) >> 2);/* Bit2 */
            byte _BackupBindingTableCache = (byte) ((_ServerMask_BYTES & 0x08) >> 3);/* Bit3 */
            byte _PrimaryDiscoveryCache = (byte) ((_ServerMask_BYTES & 0x10) >> 4);/* Bit4 */
            byte _BackupDiscoveryCache = (byte) ((_ServerMask_BYTES & 0x20) >> 5);/* Bit5 */
            _serverMask.setPrimaryTrustCenter((_PrimaryTrustCenter == 1 ? true : false));
            _serverMask.setBackupTrustCenter((_BackupTrustCenter == 1 ? true : false));
            _serverMask.setPrimaryBindingTableCache((_PrimaryBindingTableCache == 1 ? true : false));
            _serverMask.setBackupBindingTableCache((_BackupBindingTableCache == 1 ? true : false));
            _serverMask.setPrimaryDiscoveryCache((_PrimaryDiscoveryCache == 1 ? true : false));
            _serverMask.setBackupDiscoveryCache((_BackupDiscoveryCache == 1 ? true : false));
            _node.setServerMask(_serverMask);

            /* MaximumOutTransferSize_BYTES */
            int _MaximumOutTransferSize_BYTES = DataManipulation.toIntFromShort((byte) message[17],
                    (byte) message[16]);
            _node.setMaximumOutgoingTransferSize(_MaximumOutTransferSize_BYTES);

            /* CapabilityField_BYTES */
            byte _CapabilityField_BYTES = (byte) message[18];
            DescriptorCapability _DescriptorCapability = new DescriptorCapability();
            byte _ExtendedActiveEndpointListAvailable = (byte) (_CapabilityField_BYTES & 0x01);/* Bit0 */
            byte _ExtendedSimpleDescriptorListAvailable = (byte) ((_CapabilityField_BYTES
                    & 0x02) >> 1);/* Bit1 */
            _DescriptorCapability.setExtendedActiveEndpointListAvailable(
                    (_ExtendedActiveEndpointListAvailable == 1 ? true : false));
            _DescriptorCapability.setExtendedSimpleDescriptorListAvailable(
                    (_ExtendedSimpleDescriptorListAvailable == 1 ? true : false));
            _node.setDescriptorCapabilityField(_DescriptorCapability);
            String _key = String.format("%04X", _NWKAddressOfInterest);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NODE_DESCRIPTOR && pl.get_Key().equalsIgnoreCase(_key)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);/* Status */
                            pl.set_objectOfResponse(_node);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* NMLE-SET.Confirm */
        else if (_command == FreescaleConstants.NMLESETConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NMLE-SET.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NMLE_SET) {

                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* APSME-SET.Confirm */
        else if (_command == FreescaleConstants.APSMESetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSME-SET.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.APSME_SET) {

                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-Mgmt_Permit_Join.response */
        else if (_command == FreescaleConstants.ZDPMgmt_Permit_JoinResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Permit_Join.response", message);
            short status = message[3];
            String mess = "";

            switch (status) {
            case 0x00:

                break;
            case 0x80:
                mess = "InvRequestType";
                break;
            case 0x84:
                mess = "Not Supported";
                break;
            case 0x87:
                mess = "Table Full";
                break;
            case 0x8D:
                mess = "NOT AUTHORIZED";
                break;
            case 0xC5:
                mess = "Already present in the network";
                break;

            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.PERMIT_JOIN) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }
        }

        /* APS-ClearDeviceKeyPairSet.Confirm */
        else if (_command == FreescaleConstants.APSClearDeviceKeyPairSetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("APS-ClearDeviceKeyPairSet.Confirm", message);
            short status = message[3];
            String mess = "";
            switch (status) {
            case 0x00:

                break;
            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CLEAR_DEVICE_KEY_PAIR_SET) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }

        }

        /* ZTC-ClearNeighborTableEntry.Confirm */
        else if (_command == FreescaleConstants.ZTCClearNeighborTableEntryConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("ZTC-ClearNeighborTableEntry.Confirm", message);
            short status = message[3];
            String mess = "";
            switch (status) {
            case 0x00:

                break;
            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CLEAR_NEIGHBOR_TABLE_ENTRY) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }

        }

        /* NLME-JOIN.Confirm */
        else if (_command == FreescaleConstants.NLMEJOINConfirm) {
            short _status = message[8];
            switch (_status) {
            case 0x00:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: SUCCESS (Joined the network)");
                }
                break;
            case 0xC2:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: INVALID_REQUEST (Not Valid Request)");
                }
                break;
            case 0xC3:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NOT_PERMITTED (Not allowed to join the network)");
                }
                break;
            case 0xCA:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_NETWORKS (Network not found)");
                }
                break;
            case 0x01:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: PAN_AT_CAPACITY (PAN at capacity)");
                }
                break;
            case 0x02:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: PAN_ACCESS_DENIED (PAN access denied)");
                }
                break;
            case 0xE1:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: CHANNEL_ACCESS_FAILURE (Transmission failed due to activity on the channel)");
                }
                break;
            case 0xE4:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: FAILED_SECURITY_CHECK (The received frame failed security check)");
                }
                break;
            case 0xE8:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: INVALID_PARAMETER (A parameter in the primitive is out of the valid range)");
                }
                break;
            case 0xE9:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_ACK (Acknowledgement was not received)");
                }
                break;
            case 0xEB:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: NO_DATA (No response data was available following a request)");
                }
                break;
            case 0xF3:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: UNAVAILABLE_KEY (The appropriate key is not available in the ACL)");
                }
                break;
            case 0xEA:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_BEACON (No Networks)");
                }
                break;
            default:
                throw new Exception("Extracted NLME-JOIN.Confirm: Invalid Status - " + _status);
            }
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-JOIN.Confirm", message);
        }

        /* ZDO-NetworkState.Event */
        else if (_command == FreescaleConstants.ZDONetworkStateEvent) {
            short _status = message[3];
            String mess;
            switch (_status) {
            case 0x00:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted ZDO-NetworkState.Event: DeviceInitialized (Device Initialized)");
                }
                break;
            case 0x01:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinNetworkDiscoveryState (Device in Network Discovery State)");
                }
                break;
            case 0x02:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceJoinNetworkstate (Device Join Network state)");
                }
                break;
            case 0x03:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinCoordinatorstartingstate (Device in Coordinator starting state)");
                }
                gal.setGatewayStatus(GatewayStatus.GW_STARTING);
                break;
            case 0x04:
                mess = "ZDO-NetworkState.Event: DeviceinRouterRunningstate (Device in Router Running state)";
                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x05:
                mess = "ZDO-NetworkState.Event: DeviceinEndDeviceRunningstate (Device in End Device Running state)";
                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);

                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x09:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinleavenetworkstate (Device in leave network state)");
                }

                gal.setGatewayStatus(GatewayStatus.GW_STOPPING);
                break;
            case 0x0A:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinauthenticationstate (Device in authentication state)");
                }
                break;
            case 0x0B:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinstoppedstate (Device in stopped state)");
                }
                gal.setGatewayStatus(GatewayStatus.GW_STOPPED);

                break;
            case 0x0C:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinOrphanjoinstate (Device in Orphan join state)");
                }
                break;
            case 0x10:
                mess = "ZDO-NetworkState.Event: DeviceinCoordinatorRunningstate (Device is Coordinator Running state)";

                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x11:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinKeytransferstate (Device in Key transfer state)");
                }
                break;
            case 0x12:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinauthenticationstate (Device in authentication state)");
                }
                break;
            case 0x13:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceOfftheNetwork (Device Off the Network)");
                }
                break;
            default:
                throw new Exception("ZDO-NetworkState.Event: Invalid Status - " + _status);
            }
        }
        /* MacSetPIBAttribute.Confirm */
        else if (_command == FreescaleConstants.MacSetPIBAttributeConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacSetPIBAttribute.Confirm", message);
        }
        /* NLME-ENERGY-SCAN.Request */
        else if (_command == FreescaleConstants.NLMEENERGYSCANRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-ENERGY-SCAN.Request", message);
        }
        /* MacScan.Request */
        else if (_command == FreescaleConstants.MacScanRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Request", message);
        }
        /* MacScan.Confirm */
        else if (_command == FreescaleConstants.MacScanConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Confirm", message);
        }
        /* NLME-ENERGY-SCAN.confirm */
        else if (_command == FreescaleConstants.NLMEENERGYSCANconfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-ENERGY-SCAN.confirm", message);
        }
        /* NLME-NETWORK-DISCOVERY.Request */
        else if (_command == FreescaleConstants.NLMENETWORKDISCOVERYRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-DISCOVERY.Request", message);
        }
        /* MacScan.Request */
        else if (_command == FreescaleConstants.MacScanRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Request", message);
        }
        /* NLME-NETWORK-DISCOVERY.Confirm */
        else if (_command == FreescaleConstants.NLMENetworkDiscoveryConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-DISCOVERY.Confirm", message);
        }
        /* NLME-NETWORK-FORMATION.Request */
        else if (_command == FreescaleConstants.NLMENETWORKFORMATIONRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Request", message);
        }
        /* NLME-SET.Request */
        else if (_command == FreescaleConstants.NLMESetRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-SET.Request", message);
        }
        /* NLME-NWK-STATUS.Indication */
        else if (_command == FreescaleConstants.NLMENwkStatusIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-NWK-STATUS.Indication", message);
        }
        /* NLME-ROUTE-DISCOVERY.confirm */
        else if (_command == FreescaleConstants.NLMENWKSTATUSIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-ROUTE-DISCOVERY.confirm", message);
        } else {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted a Message not in Message Management", message);
        }

        synchronized (this) {
            _size = messages.size();
        }
    }

}

From source file:io.warp10.continuum.gts.GTSHelper.java

public static final long labelsId_slow(byte[] key, Map<String, String> labels) {
    ////  ww  w . ja  v  a2 s . com
    // Allocate an array to hold both name and value hashes
    //

    long[] hashes = new long[labels.size() * 2];

    //
    // Compute hash for each name and each value
    //

    int idx = 0;

    long[] sipkey = SipHashInline.getKey(key);

    for (Entry<String, String> entry : labels.entrySet()) {
        hashes[idx] = SipHashInline.hash24_palindromic(sipkey[0], sipkey[1],
                entry.getKey().getBytes(Charsets.UTF_8));
        hashes[idx + 1] = SipHashInline.hash24_palindromic(sipkey[0], sipkey[1],
                entry.getValue().getBytes(Charsets.UTF_8));
        idx += 2;
    }

    //
    // Sort array by label hash then value hash.
    // Given the normally reduced number of labels, we can use a simple bubble sort...
    //

    for (int i = 0; i < labels.size() - 1; i++) {
        for (int j = i + 1; j < labels.size(); j++) {
            if (hashes[i * 2] > hashes[j * 2]) {
                //
                // We need to swap name and value ids at i and j
                //
                long tmp = hashes[j * 2];
                hashes[j * 2] = hashes[i * 2];
                hashes[i * 2] = tmp;
                tmp = hashes[j * 2 + 1];
                hashes[j * 2 + 1] = hashes[i * 2 + 1];
                hashes[i * 2 + 1] = tmp;
            } else if (hashes[i * 2] == hashes[j * 2] && hashes[i * 2 + 1] > hashes[j * 2 + 1]) {
                //
                // We need to swap value ids at i and j
                //
                long tmp = hashes[j * 2 + 1];
                hashes[j * 2 + 1] = hashes[i * 2 + 1];
                hashes[i * 2 + 1] = tmp;
            }
        }
    }

    //
    // Now compute the SipHash of all the longs in the order we just determined
    // 

    byte[] buf = new byte[hashes.length * 8];
    ByteBuffer bb = ByteBuffer.wrap(buf);
    bb.order(ByteOrder.BIG_ENDIAN);

    for (long hash : hashes) {
        bb.putLong(hash);
    }

    //return SipHashInline.hash24(sipkey[0], sipkey[1], buf, 0, buf.length);
    return SipHashInline.hash24_palindromic(sipkey[0], sipkey[1], buf, 0, buf.length);
}