endpointroutermessage.java

jxta_src_2.41b jxta 2.41b 最新版源码 from www.jxta.org

        // if anything was in the message

        XMLDocument doc = (XMLDocument)
                          StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, Name);


        doc.addAttribute("xmlns:jxta", "http://jxta.org");

        Element e = null;

        if (srcAddress != null) {
            e = doc.createElement(SrcTag, srcAddress);
            doc.appendChild(e);
        }

        if (destAddress != null) {
            e = doc.createElement(DestTag, destAddress);
            doc.appendChild(e);
        }

        if (lastHop != null) {
            e = doc.createElement(LastHopTag, lastHop);
            doc.appendChild(e);
        }

        AccessPointAdvertisement gateway = null;

        e = doc.createElement(GatewayForwardTag);
        doc.appendChild(e);
        if ((forwardGateways != null) && (forwardGateways.size() > 0)) {
            if (forwardCache != null) {
                for (int i = 0; i < forwardCache.size(); ++i) {
                    try {
                        Element xptDoc = (Element) forwardCache.elementAt(i);

                        StructuredDocumentUtils.copyElements(doc, e, xptDoc);
                    } catch (Exception e1) {
                        if (LOG.isEnabledFor(Level.WARN)) {
                            LOG.warn("Forward cache failed");
                        }
                        forwardCache = null;
                        break;
                    }
                }
            } else {
                for (int i = 0; i < forwardGateways.size(); ++i) {
                    try {
                        gateway = (AccessPointAdvertisement) forwardGateways.elementAt(i);
                        XMLDocument xptDoc = (XMLDocument) gateway.getDocument(MimeMediaType.XMLUTF8);

                        StructuredDocumentUtils.copyElements(doc, e, xptDoc);
                    } catch (Exception e1) {
                        continue;
                    }
                }
            }
        }

        gateway = null;
        e = doc.createElement(GatewayReverseTag, gateway);
        doc.appendChild(e);
        if ((reverseGateways != null) && (reverseGateways.size() > 0)) {
            if (reverseCache != null) {
                for (int i = 0; i < reverseCache.size(); ++i) {
                    try {
                        Element xptDoc = (Element) reverseCache.elementAt(i);

                        StructuredDocumentUtils.copyElements(doc, e, xptDoc);
                    } catch (Exception e1) {
                        if (LOG.isEnabledFor(Level.WARN)) {
                            LOG.warn("Reverse cache failed");
                        }
                        reverseCache = null;
                        break;
                    }
                }
            } else {
                for (int i = 0; i < reverseGateways.size(); ++i) {
                    try {
                        gateway = (AccessPointAdvertisement) reverseGateways.elementAt(i);
                        XMLDocument xptDoc = (XMLDocument) gateway.getDocument(MimeMediaType.XMLUTF8);

                        StructuredDocumentUtils.copyElements(doc, e, xptDoc);
                    } catch (Exception e1) {
                        continue;
                    }
                }
            }
        }

        if (radv != null) {
            try {
                XMLDocument radvDoc = (XMLDocument) radv.getDocument(MimeMediaType.XMLUTF8);

                StructuredDocumentUtils.copyElements(doc, doc, radvDoc);
            } catch (Exception e1) {
                if (LOG.isEnabledFor(Level.WARN)) {
                    LOG.warn("Cannot add route advertisement");
                }
            }
        }

        rmElem = new TextDocumentMessageElement(MESSAGE_NAME, doc, null);
        message.replaceMessageElement(MESSAGE_NS, rmElem);

        rmDirty = false;
    }

    public void setSrcAddress(EndpointAddress address) {
        rmExists = true;
        rmDirty = true;
        srcAddress = address.toString();
    }

    public EndpointAddress getSrcAddress() {
        return new EndpointAddress(srcAddress);
    }

    public void setDestAddress(EndpointAddress address) {
        rmExists = true;
        rmDirty = true;
        destAddress = address.toString();
    }

    public EndpointAddress getDestAddress() {
        return new EndpointAddress(destAddress);
    }

    public void setLastHop(String lhop) {
        rmExists = true;
        rmDirty = true;
        lastHop = lhop;
    }

    public String getLastHop() {
        return lastHop;
    }

    public void setForwardHops(Vector fhops) {
        rmExists = true;
        rmDirty = true;
        forwardGateways = fhops;
        forwardCache = null;
    }

    public Vector getForwardHops() {
        return forwardGateways;
    }

    public void prependReverseHop(AccessPointAdvertisement apa) {
        rmExists = true;
        rmDirty = true;
        if (reverseGateways == null) {
            reverseGateways = new Vector();
            reverseCache = new Vector();
        }

        reverseGateways.add(0, apa);

        if (reverseCache == null) {
            return;
        }

        // if we still have a cache (we where able to keep it conistent, update it
        XMLDocument apDoc = (XMLDocument) apa.getDocument(MimeMediaType.XMLUTF8);

        reverseCache.add(0, apDoc);
    }

    // Do not call this routine lightly: it blasts the cache.
    public void setReverseHops(Vector rhops) {
        rmExists = true;
        rmDirty = true;

        // No inplace changes allowed, we need to keep the cache
        // consistent: clone

        if (rhops == null) {
            reverseGateways = null;
        } else {
            reverseGateways = (Vector) rhops.clone();
        }

        // Not worth updating the cache. Blast it.
        reverseCache = null;
    }

    public Vector getReverseHops() {

        if (reverseGateways == null) {
            return null;
        }

        // No inplace changes allowed, we need to keep the cache
        // consistent: clone

        return (Vector) reverseGateways.clone();
    }

    public RouteAdvertisement getRouteAdv() {
        return radv;
    }

    public void setRouteAdv(RouteAdvertisement radv) {
        rmExists = true;
        rmDirty = true;
        this.radv = radv;
    }

    // Used only for debugging
    public String display() {
        StringBuffer msgInfo = new StringBuffer("Process Incoming : ");

        msgInfo.append("\n\tsrc=");
        msgInfo.append((srcAddress != null) ? srcAddress : "none");
        msgInfo.append("\n\tdest== ");
        msgInfo.append((destAddress != null) ? destAddress : "none");
        msgInfo.append("\n\tlastHop= ");
        msgInfo.append((lastHop != null) ? lastHop : "none");
        msgInfo.append("\n\tembedded radv= ");
        msgInfo.append(radv != null ? radv.display() : "none");

        if (forwardGateways != null) {
            msgInfo.append("    Forward Hops:");
            for (int i = 0; i < forwardGateways.size(); ++i) {
                try {
                    msgInfo.append("   [" + i + "] ");
                    msgInfo.append(((AccessPointAdvertisement)
                                    forwardGateways.elementAt(i)).getPeerID());
                } catch (Exception ez1) {
                    break;
                }
            }
        }

        if (reverseGateways != null) {
            msgInfo.append("    Reverse Hops:");
            for (int i = 0; i < reverseGateways.size(); ++i) {
                try {
                    msgInfo.append("   [" + i + "] ");
                    msgInfo.append(((AccessPointAdvertisement)
                                    reverseGateways.elementAt(i)).getPeerID());
                } catch (Exception ez1) {
                    break;
                }
            }
        }

        return msgInfo.toString();
    }

    // This will ensure that all older elements will be removed from
    // the message in case they do not get replaced by new ones before
    // updateMsg is called.

    public void clearAll() {

        if (rmExists) {
            rmDirty = true;

            srcAddress = null;
            destAddress = null;
            lastHop = null;
            forwardGateways = null;
            reverseGateways = null;
            radv = null;
            rmExists = false;
        }
    }
}