Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
    * JBoss, Home of Professional Open Source
    * Copyright 2005, JBoss Inc., and individual contributors as indicated
    * by the @authors tag. See the copyright.txt in the distribution for a
    * full listing of individual contributors.
    *
    * This is free software; you can redistribute it and/or modify it
    * under the terms of the GNU Lesser General Public License as
    * published by the Free Software Foundation; either version 2.1 of
   * the License, or (at your option) any later version.
   *
   * This software is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this software; if not, write to the Free
   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
   */
 package org.jboss.xb.binding;
 
 import  com.wutka.dtd.DTD;
 import  com.wutka.dtd.DTDAttribute;
 import  com.wutka.dtd.DTDContainer;
 import  com.wutka.dtd.DTDElement;
 import  com.wutka.dtd.DTDEmpty;
 import  com.wutka.dtd.DTDItem;
 import  com.wutka.dtd.DTDMixed;
 import  com.wutka.dtd.DTDName;
 import  com.wutka.dtd.DTDPCData;
 import  com.wutka.dtd.DTDParser;
 import  com.wutka.dtd.DTDCardinal;
 import  org.jboss.logging.Logger;
 
 import java.io.Reader;
 import java.io.Writer;
 import java.util.Map;
 import java.util.List;
 import java.net.URL;
A DTD based org.jboss.xb.binding.Marshaller implementation.

Author(s):
Alexey Loubyansky
Version:
$Revision: 2009 $
 
 public class DtdMarshaller
    extends AbstractMarshaller
 {
    private static final Logger log = Logger.getLogger(DtdMarshaller.class);
 
    private String publicId;
    private String systemId;
 
    private final Stack stack = new StackImpl();
    private DTD dtd;
    private Content content = new Content();
 
    private final List elementStack = new ArrayList();
 
    private final Map simpleTypeBindings = new HashMap();
 
    public void addBinding(String elementNameTypeBinding binding)
    {
       .put(elementNamebinding);
    }
 
    public void mapPublicIdToSystemId(String publicIdString systemId)
    {
       this. = publicId;
       this. = systemId;
    }
 
    public void declareNamespace(String prefixString uri)
    {
       throw new UnsupportedOperationException("declareNamespace is not implemented.");
    }
 
    public void addAttribute(String prefixString localNameString typeString value)
    {
       throw new UnsupportedOperationException("addAttribute is not implemented.");
   }
   public void marshal(String schemaUriObjectModelProvider providerObject rootWriter writerthrows IOException,
      SAXException
   {
      URL url;
      try
      {
         url = new URL(schemaUri);
      }
      catch(MalformedURLException e)
      {
         throw new IllegalArgumentException("Malformed schema URI " + schemaUri + ": " + e.getMessage());
      }
      InputStream is;
      try
      {
         is = url.openStream();
      }
      catch(IOException e)
      {
         throw new IllegalStateException("Failed to open input stream for schema " + schemaUri + ": " + e.getMessage());
      }
      try
      {
         InputStreamReader reader = new InputStreamReader(is);
         marshal(readerproviderrootwriter);
      }
      finally
      {
         is.close();
      }
   }
   public void marshal(Reader dtdReaderObjectModelProvider providerObject documentWriter writer)
      throws IOExceptionSAXException
   {
      DTDParser parser = new DTDParser(dtdReader);
       = parser.parse(true);
      this. = provider instanceof GenericObjectModelProvider ?
         (GenericObjectModelProvider)provider : new DelegatingObjectModelProvider(provider);
      //stack.push(document);
      DTDElement[] roots = null;
      if(. != null)
      {
         handleRootElement(document.);
      }
      else
      {
         roots = getRootList();
         for(int i = 0; i < roots.length; ++i)
         {
            handleRootElement(documentroots[i]);
         }
      }
      //stack.pop();
      // version & encoding
      writeXmlVersion(writer);
      // DOCTYPE
      writer.write("<!DOCTYPE ");
      if(. != null)
      {
         writer.write(..getName());
      }
      else
      {
         for(int i = 0; i < roots.length; ++i)
         {
            writer.write(", ");
            writer.write(roots[i].getName());
         }
      }
      writer.write(" PUBLIC \"");
      writer.write();
      writer.write("\" \"");
      writer.write();
      writer.write("\">\n");
      .handleContent(contentWriter);
   }
   private void handleRootElement(Object ofinal DTDElement dtdRoot)
   {
      Element el = new Element(dtdRoottrue);
      .add(el);
      .startDocument();
      Object root = .getRoot(onulldtdRoot.getName());
      if(root == null)
      {
         return;
      }
      .push(root);
      Attributes attrs = provideAttributes(dtdRootroot);
      .startElement(""dtdRoot.getName(), dtdRoot.getName(), attrs);
      handleElement(dtdRootattrs);
      .endElement(""dtdRoot.getName(), dtdRoot.getName());
      .pop();
      .endDocument();
      .remove(.size() - 1);
   }
   private final void handleElement(DTD dtd, DTDElement elementAttributes attrs)
   {
      DTDItem item = element.content;
      if(item instanceof DTDMixed)
      {
         handleMixedElement(elementattrs);
      }
      else if(item instanceof DTDEmpty)
      {
         final Object value = .getElementValue(.peek(), nullelement.getName());
         if(..equals(value))
         {
            writeSkippedElements();
            .startElement(""element.getName(), element.getName(), attrs);
            .endElement(""element.getName(), element.getName());
         }
      }
      else if(item instanceof DTDContainer)
      {
         processContainer(dtd, (DTDContainer)item);
      }
      else
      {
         throw new IllegalStateException("Unexpected element: " + element.getName());
      }
   }
   private final void handleMixedElement(DTDElement elementAttributes attrs)
   {
      boolean startElement = false;
      if(!.isEmpty())
      {
         Element e = (Element.get(.size() - 1);
         startElement = element != e.element;
      }
      
      DTDMixed mixed = (DTDMixed) element.content;
      String elementName = element.getName();
      Object parent = .peek();
      DTDItem[] items = mixed.getItems();
      for(int i = 0; i < items.length; ++i)
      {
         DTDItem item = items[i];
         if(item instanceof DTDPCData)
         {
            Object value = .getElementValue(parentnullelementName);
            if(value != null)
            {
               writeSkippedElements();
               String marshalled;
               TypeBinding binding = (TypeBinding).get(elementName);
               if(binding != null)
               {
                  marshalled = binding.marshal(value);
               }
               else
               {
                  marshalled = value.toString();
               }
               char[] ch = marshalled.toCharArray();
               if(startElement)
               {
                  .startElement(""elementNameelementNameattrs);
               }
               
               .characters(ch, 0, ch.length);
               if(startElement)
               {
                  .endElement(""elementNameelementName);
               }
            }
         }
      }
   }
   private final void handleChildren(DTD dtd, DTDElement element, DTDCardinal elementCardinal)
   {
      Object parent = .peek();
      Object children = .getChildren(parentnullelement.getName());
      if(children != null)
      {
         Iterator iter;
         if(children instanceof Iterator)
         {
            iter = (Iterator)children;
         }
         else if(children instanceof Collection)
         {
            iter = ((Collection)children).iterator();
         }
         else
         {
            iter = Collections.singletonList(children).iterator();
         }
         writeSkippedElements();
         Element el = new Element(elementtrue);
         .add(el);
         final boolean singleValued = elementCardinal == DTDCardinal.NONE || elementCardinal == DTDCardinal.OPTIONAL;
         if(singleValued)
         {
            // todo attributes!
            .startElement(""element.getName(), element.getName(), null);
         }
         while(iter.hasNext())
         {
            Object child = iter.next();
            .push(child);
            AttributesImpl attrs = (element.attributes.isEmpty() ? null : provideAttributes(elementchild));
            if(!singleValued)
            {
               .startElement(""element.getName(), element.getName(), attrs);
            }
            handleElement(dtdelementattrs);
            if(!singleValued)
            {
               .endElement(element.getName(), element.getName());
            }
            .pop();
         }
         if(singleValued)
         {
            .endElement(element.getName(), element.getName());
         }
         .remove(.size() - 1);
      }
      else
      {
         boolean removeLast = false;
         if(!(element.getContent() instanceof DTDMixed || element.getContent() instanceof DTDEmpty))
         {
            Element el = new Element(element);
            .add(el);
            removeLast = true;
         }
         AttributesImpl attrs = (element.attributes.isEmpty() ? null : provideAttributes(elementparent));
         handleElement(dtdelementattrs);
         if(removeLast)
         {
            Element el = (Element).remove(.size() - 1);
            if(el.started)
            {
               DTDElement started = el.element;
               .endElement(""started.getName(), started.getName());
            }
         }
      }
   }
   private final void processContainer(DTD dtd, DTDContainer container)
   {
      DTDItem[] items = container.getItems();
      for(int i = 0; i < items.length; ++i)
      {
         DTDItem item = items[i];
         if(item instanceof DTDContainer)
         {
            processContainer(dtd, (DTDContainer)item);
         }
         else if(item instanceof DTDName)
         {
            DTDName name = (DTDName)item;
            DTDElement element = (DTDElement)dtd.elements.get(name.value);
            handleChildren(dtdelementname.getCardinal());
         }
      }
   }
   private void writeSkippedElements()
   {
      Element el = (Element).get(.size() - 1);
      if(!el.started)
      {
         int firstNotStarted = .size() - 1;
         do
         {
            el = (Element).get(--firstNotStarted);
         }
         while(!el.started);
         ++firstNotStarted;
         while(firstNotStarted < .size())
         {
            el = (Element).get(firstNotStarted++);
            DTDElement notStarted = el.element;
            if(.isTraceEnabled())
            {
               .trace("starting skipped> " + notStarted.getName());
            }
            .startElement(""notStarted.getName(), notStarted.getName(), null);
            el.started = true;
         }
      }
   }
   private AttributesImpl provideAttributes(DTDElement elementObject container)
   {
      final Hashtable attributes = element.attributes;
      AttributesImpl attrs = new AttributesImpl(attributes.size());
      for(Iterator attrIter = attributes.values().iterator(); attrIter.hasNext();)
      {
         DTDAttribute attr = (DTDAttribute)attrIter.next();
         final Object attrValue = .getAttributeValue(containernullattr.getName());
         if(attrValue != null)
         {
            attrs.add(,
               attr.getName(),
               attr.getName(),
               attr.getType().toString(),
               attrValue.toString()
            );
         }
      }
      return attrs;
   }

   

Parameters:
dtd the DTD object model
Returns:
root element names
   protected static DTDElement[] getRootList(DTD dtd)
   {
      Hashtable roots = new Hashtable();
      Enumeration e = dtd.elements.elements();
      while(e.hasMoreElements())
      {
         DTDElement element = (DTDElement)e.nextElement();
         roots.put(element.name, element);
      }
      e = dtd.elements.elements();
      while(e.hasMoreElements())
      {
         DTDElement element = (DTDElement)e.nextElement();
         if(!(element.content instanceof DTDContainer))
         {
            continue;
         }
         Enumeration items = ((DTDContainer)element.content).getItemsVec().elements();
         while(items.hasMoreElements())
         {
            removeElements(rootsdtd, (DTDItem)items.nextElement());
         }
      }
      final Collection rootCol = roots.values();
      return (DTDElement[])rootCol.toArray(new DTDElement[rootCol.size()]);
   }
   protected static void removeElements(Hashtable h, DTD dtd, DTDItem item)
   {
      if(item instanceof DTDName)
      {
         h.remove(((DTDName)item).value);
      }
      else if(item instanceof DTDContainer)
      {
         Enumeration e = ((DTDContainer)item).getItemsVec().elements();
         while(e.hasMoreElements())
         {
            removeElements(hdtd, (DTDItem)e.nextElement());
         }
      }
   }
   // Inner
   private static final class Element
   {
      public final DTDElement element;
      public boolean started;
      public Element(DTDElement elementboolean started)
      {
         this. = element;
         this. = started;
      }
      public Element(DTDElement element)
      {
         this. = element;
      }
      public String toString()
      {
         return "[element=" + .getName() + ", started=" +  + "]";
      }
   }
New to GrepCode? Check out our FAQ X