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  org.jboss.logging.Logger;
 import  org.apache.xerces.xs.XSTypeDefinition;
 
 import java.util.Map;
 import java.util.List;
An instance of this class translates SAX events into org.jboss.xml.binding.GenericObjectModelFactory calls such as newChild, addChild and setValue. WARN: this implementation is not thread-safe!

Author(s):
Alexey Loubyansky
Version:
$Revision: 2420 $
 
 public class ObjectModelBuilder
 {
   
logger
 
    private static final Logger log = Logger.getLogger(ObjectModelBuilder.class);

   
The object that represents an ignored by the object model factory XML element, i.e. the factory returned null from its newChild method
 
    private static final Object IGNORED = new Object();

   
The root of the unmarshalled object graph
 
    private Object root;

   
the stack of all the objects including IGNORED
 
    private Stack all = new StackImpl();

   
the stack of only accepted objects (all - IGNORED)
 
    private Stack accepted = new StackImpl();
 
    private String curNsSwitchingFactory;
    private Stack nameSwitchingFactory;
    private Stack nsSwitchingFactory;

   
default object model factory
 
factories mapped to namespace URIs
 
    private Map factoriesToNs = .;

   
NamespaceContext implementation
 
    private final NamespaceRegistry nsRegistry = new NamespaceRegistry();
 
    // whether text content should be trimmed before it is set
   private boolean trimTextContent = true//  for backwards compatibility
   private XSTypeDefinition currentType;
   private boolean trace = .isTraceEnabled();
   // Public
   public void mapFactoryToNamespace(ObjectModelFactory factoryString namespaceUri)
   {
      {
          = new HashMap();
      }
      .put(namespaceUrigetGenericObjectModelFactory(factory));
   }
   public void init(ObjectModelFactory defaultFactoryObject root)
   {
      this. = getGenericObjectModelFactory(defaultFactory);
      .clear();
      .clear();
      this. = root;
   }
   public void pushFactory(String namespaceURIString localNameGenericObjectModelFactory factory)
   {
      if( != null)
      {
         if( == null)
         {
             = new StackImpl();
             = new StackImpl();
         }
      }
       = namespaceURI;
       = localName;
       = factory;
   }
   public void popFactory()
   {
      if( == null || .isEmpty())
      {
          = null;
          = null;
      }
      else
      {
      }
   }
   // UnmarshallingContext implementation
   public Iterator getNamespaceURIs()
   {
      return .getRegisteredURIs();
   }
   {
      return ;
   }
   public boolean isTrimTextContent()
   {
      return ;
   }
   
   public void setTrimTextContent(boolean trimTextContent)
   {
      this. = trimTextContent;
   }   

   
Construct a QName from a value

Parameters:
value A value that is of the form [prefix:]localpart
   public QName resolveQName(String value)
   {
      StringTokenizer st = new StringTokenizer(value":");
      if(st.countTokens() == 1)
         return new QName(value);
      if(st.countTokens() != 2)
         throw new IllegalArgumentException("Illegal QName: " + value);
      String prefix = st.nextToken();
      String local = st.nextToken();
      String nsURI = .getNamespaceURI(prefix);
      if (nsURI == null)
         throw new IllegalStateException("Cannot obtain namespace URI for prefix: " + prefix);
      return new QName(nsURIlocalprefix);
   }
   public String getChildContent(String namespaceURIString qName)
   {
      // todo reimplement later
      throw new UnsupportedOperationException();
      //return content.getChildContent(namespaceURI, qName);
   }
   public XSTypeDefinition getType()
   {
      return ;
   }
   // Public
   public void startPrefixMapping(String prefixString uri)
   {
      .addPrefixMapping(prefixuri);
   }
   public void endPrefixMapping(String prefix)
   {
      .removePrefixMapping(prefix);
   }
   public void processingInstruction(String targetString data)
   {
      if(!"jbossxb".equals(target))
      {
         return;
      }
      int i = data.indexOf("factory=\"");
      if(i != -1)
      {
         int end = data.indexOf('\"'i + 9);
         if(end == -1)
         {
            throw new JBossXBRuntimeException(
               "Property 'factory' is not terminated with '\"' in processing instruction: " + data
            );
         }
         String factoryProp = data.substring(i + 9, end);
         Class factoryCls;
         try
         {
            factoryCls = Thread.currentThread().getContextClassLoader().loadClass(factoryProp);
         }
         catch(ClassNotFoundException e)
         {
            throw new JBossXBRuntimeException("Failed to load factory class : " + e.getMessage(), e);
         }
         ObjectModelFactory factory;
         try
         {
            factory = (ObjectModelFactory)factoryCls.newInstance();
         }
         catch(Exception e)
         {
            throw new JBossXBRuntimeException("Failed to instantiate factory " + factoryProp + ": " + e.getMessage(),
               e
            );
         }
         i = data.indexOf("ns=\"");
         if(i == -1)
         {
            throw new JBossXBRuntimeException(
               "Property 'ns' not found in factory mapping processing instruction: " + data
            );
         }
         end = data.indexOf("\""i + 4);
         if(end == -1)
         {
            throw new JBossXBRuntimeException(
               "Property 'ns' is not terminated with '\"' in processing instruction: " + data
            );
         }
         String nsProp = data.substring(i + 4, end);
         mapFactoryToNamespace(factorynsProp);
      }
      else
      {
         throw new JBossXBRuntimeException(
            "Unexpected data in processing instruction: target=" + target + ", data=" + data
         );
      }
   }
   public Object getRoot()
   {
      if(!.isEmpty())
      {
         popAll();
         popAccepted();
      }
      return ;
   }
   public void startElement(String namespaceURI,
                            String localName,
                            String qName,
                            Attributes atts,
                            XSTypeDefinition type)
   {
      Object parent = .isEmpty() ?  : peekAccepted();
      // todo currentType assignment
       = type;
      Object element;
      if(!namespaceURI.equals())
      {
         GenericObjectModelFactory newFactory = getFactory(namespaceURI);
         if(newFactory != )
         {
            element = newFactory.newRoot(parentthisnamespaceURIlocalNameatts);
         }
         else
         {
            element = newFactory.newChild(parentthisnamespaceURIlocalNameatts);
         }
         // still have to push since curNsSwitchingFactory needs to be updated to prevent
         // newRoot calls for the children
         pushFactory(namespaceURIlocalNamenewFactory);
      }
      else
      {
         element = .newChild(parentthisnamespaceURIlocalNameatts);
      }
      if(element == null)
      {
         pushAll();
         if()
         {
            .trace("ignored " + namespaceURI + ':' + qName);
         }
      }
      else
      {
         pushAll(element);
         pushAccepted(element);
         if()
         {
            .trace("accepted " + namespaceURI + ':' + qName);
         }
      }
   }
   public void endElement(String namespaceURIString localNameString qName)
   {
      AllElement element = popAll();
      if(!.isEmpty())
      {
         Object acceptedElement = peekAccepted();
         if(element.characters != null && element.characters.length() > 0)
         {
            if()
            {
               String characters = element.characters.toString().trim();
               if (characters.length() > 0)
               {
                  .setValue(acceptedElementthisnamespaceURIlocalNamecharacters);
               }
            }
            else
            {
               .setValue(acceptedElementthisnamespaceURIlocalNameelement.characters.toString());
            }
         }
      }
      if(localName.equals() && namespaceURI.equals())
      {
         popFactory();
      }
      if(element.element != )
      {
         popAccepted();
         Object parent = (.isEmpty() ? null : peekAccepted());
         if(parent != null)
         {
            .addChild(parentelement.elementthisnamespaceURIlocalName);
         }
         else
         {
             = .completeRoot(element.elementthisnamespaceURIlocalName);
         }
      }
   }
   public void characters(char[] chint startint length)
   {
      if(!.isEmpty())
      {
         String str = String.valueOf(chstartlength);
         AllElement allElement = peekAll();
         if(allElement.characters == null)
         {
            allElement.characters = new StringBuffer(str);
         }
         else
         {
            allElement.characters.append(str);
         }
      }
   }
   // Private
   private GenericObjectModelFactory getFactory(String namespaceUri)
   {
      if(factory == null)
      {
         factory = ;
      }
      return factory;
   }
   static Object invokeFactory(Object factoryMethod methodObject[] args)
   {
      try
      {
         return method.invoke(factoryargs);
      }
      catch(InvocationTargetException e)
      {
         Throwable te = e.getCause();
         if(te instanceof RuntimeException)
         {
            throw (RuntimeException)te;
         }
         String msg = "Failed to invoke method " + method + ", factory=" + factory;
         .error(msge.getTargetException());
         IllegalStateException ise = new IllegalStateException(msg);
         ise.initCause(te);
         throw ise;
      }
      catch(Exception e)
      {
         String msg = "Failed to invoke method " + method.getName() + ", factory=" + factory;
         .error(msge);
         IllegalStateException ise = new IllegalStateException(msg);
         ise.initCause(e);
         throw ise;
      }
   }
   static Method getMethodForElement(Object factoryString nameClass[] params)
   {
      Method method = null;
      try
      {
         method = factory.getClass().getMethod(nameparams);
      }
      catch(NoSuchMethodException e)
      {
      }
      catch(SecurityException e)
      {
         throw e;
      }
      return method;
   }
   {
      if(!(factory instanceof GenericObjectModelFactory))
      {
         factory = new DelegatingObjectModelFactory(factory);
      }
      return factory instanceof GenericObjectModelFactory ?
         (GenericObjectModelFactory)factory :
         new DelegatingObjectModelFactory(factory);
   }
   private void pushAccepted(Object o)
   {
      .push(o);
   }
   private Object popAccepted()
   {
      return .pop();
   }
   private Object peekAccepted()
   {
      return .peek();
   }
   private void pushAll(Object o)
   {
      .push(new AllElement(o));
   }
   private AllElement popAll()
   {
      return (AllElement).pop();
   }
   private AllElement peekAll()
   {
      return (AllElement).peek();
   }
   private static final class AllElement
   {
      public final Object element;
      public StringBuffer characters;
      public AllElement(Object element)
      {
         this. = element;
      }
   }
   private static interface Stack
   {
      void clear();
      void push(Object o);
      Object pop();
      Object peek();
      boolean isEmpty();
   }
   private static class StackImpl
      implements Stack
   {
      private List list = new ArrayList();
      public void clear()
      {
         .clear();
      }
      public void push(Object o)
      {
         .add(o);
      }
      public Object pop()
      {
         return .remove(.size() - 1);
      }
      public Object peek()
      {
         return .get(.size() - 1);
      }
      public boolean isEmpty()
      {
         return .isEmpty();
      }
   }
New to GrepCode? Check out our FAQ X