endpointroutermessage.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

            rmDirty = false;
            return;
        }

        // The element was either created or changed. Replace whatever
        // if anything was in the message

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

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

        XMLElement e;

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

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

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

        e = doc.createElement(GatewayForwardTag);
        doc.appendChild(e);
        if ((forwardGateways != null) && (!forwardGateways.isEmpty())) {
            if (forwardCache != null) {
                for (XMLElement xptDoc : forwardCache) {
                    try {
                        StructuredDocumentUtils.copyElements(doc, e, xptDoc);
                    } catch (Exception e1) {
                        if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                            LOG.warning("Forward cache failed");
                        }
                        forwardCache = null;
                        break;
                    }
                }
            } else {
                for (AccessPointAdvertisement gateway : forwardGateways) {
                    try {
                        XMLDocument xptDoc = (XMLDocument) gateway.getDocument(MimeMediaType.XMLUTF8);
                        StructuredDocumentUtils.copyElements(doc, e, xptDoc);
                    } catch (Exception ignored) {
                        //ignored
                    }
                }
            }
        }

        e = doc.createElement(GatewayReverseTag);
        doc.appendChild(e);
        if ((reverseGateways != null) && (!reverseGateways.isEmpty())) {
            if (reverseCache != null) {
                for (XMLElement xptDoc : reverseCache) {
                    try {
                        StructuredDocumentUtils.copyElements(doc, e, xptDoc);
                    } catch (Exception e1) {
                        if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                            LOG.warning("Reverse cache failed");
                        }
                        reverseCache = null;
                        break;
                    }
                }
            } else {
                 for (AccessPointAdvertisement gateway : reverseGateways) {
                    try {
                        XMLDocument xptDoc = (XMLDocument) gateway.getDocument(MimeMediaType.XMLUTF8);
                        StructuredDocumentUtils.copyElements(doc, e, xptDoc);
                    } catch (Exception e1) {
                        // ignored
                    }
                }
            }
        }

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

                StructuredDocumentUtils.copyElements(doc, doc, radvDoc);
            } catch (Exception e1) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.warning("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;
    }

    public EndpointAddress getSrcAddress() {
        return srcAddress;
    }

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

    public EndpointAddress getDestAddress() {
        return destAddress;
    }

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

    public EndpointAddress getLastHop() {
        return lastHop;
    }

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

    public Vector<AccessPointAdvertisement> getForwardHops() {
        return forwardGateways;
    }

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

        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<AccessPointAdvertisement> 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<AccessPointAdvertisement>) rhops.clone();
        }

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

    public Vector<AccessPointAdvertisement> getReverseHops() {

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

        return (Vector<AccessPointAdvertisement>) 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() {
        StringBuilder msgInfo = new StringBuilder("Endpoint Router Message : ");

        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("\n\tForward Hops:");
            for (int i = 0; i < forwardGateways.size(); ++i) {
                try {
                    msgInfo.append("   [").append(i).append("] ");
                    msgInfo.append(forwardGateways.elementAt(i).getPeerID());
                }
                catch (Exception ez1) {
                    break;
                }
            }
        }
        if (reverseGateways != null) {
            msgInfo.append("\n\tReverse Hops:");
            for (int i = 0; i < reverseGateways.size(); ++i) {
                    msgInfo.append("   [").append(i).append("] ");
                    msgInfo.append(reverseGateways.elementAt(i).getPeerID());
            }
        }
        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;
        }
    }
}