Examples of org.jboss.xb.binding.sunday.unmarshalling.ModelGroupBinding

Package org.jboss.xb.binding.sunday.unmarshalling

Examples of org.jboss.xb.binding.sunday.unmarshalling.ModelGroupBinding

org.jboss.xb.binding.sunday.unmarshalling.ModelGroupBinding
@author Alexey Loubyansky @version $Revision: 2138 $

/* 1205 */     XmlTransient xmlTransient = (XmlTransient)property.getUnderlyingAnnotation(XmlTransient.class);
/* 1206 */     if ((xmlTransient != null) && (propertyOrder != null)) {
/* 1207 */       throw new RuntimeException("Property " + property.getName() + " in property order " + Arrays.asList(propertyOrder) + " is marked @XmlTransient");
/*      */     }
/*      */ 
/* 1211 */     ModelGroupBinding localModel = model;
/*      */ 
/* 1214 */     if (propertyType.isArray())
/*      */     {
/* 1216 */       if (this.trace)
/* 1217 */         log.trace("Property " + property.getName() + " is an array");
/* 1218 */       localModel = createArray(localModel);
/*      */     }
/* 1220 */     else if (propertyType.isCollection())
/*      */     {
/* 1222 */       if (this.trace)
/* 1223 */         log.trace("Property " + property.getName() + " is a collection");
/* 1224 */       localModel = createCollection(localModel);
/*      */ 
/* 1226 */       JBossXmlCollection xmlCol = (JBossXmlCollection)property.getUnderlyingAnnotation(JBossXmlCollection.class);
/* 1227 */       if (xmlCol != null)
/*      */       {
/* 1230 */         propertyType = propertyType.getTypeInfoFactory().getTypeInfo(xmlCol.type());
/*      */       }
/*      */ 
/*      */     }
/* 1234 */     else if (!property.getType().isPrimitive())
/*      */     {
/* 1236 */       ClassInfo propClassInfo = (ClassInfo)property.getType();
/*      */ 
/* 1239 */       XmlElement propXmlElement = (XmlElement)property.getUnderlyingAnnotation(XmlElement.class);
/* 1240 */       if (propXmlElement != null)
/*      */       {
/* 1242 */         propClassInfo = (ClassInfo)propClassInfo.getTypeInfoFactory().getTypeInfo(propXmlElement.type());
/*      */       }
/*      */ 
/* 1245 */       JBossXmlModelGroup xmlModelGroup = (JBossXmlModelGroup)propClassInfo.getUnderlyingAnnotation(JBossXmlModelGroup.class);
/* 1246 */       if ((xmlModelGroup != null) && (xmlModelGroup.particles().length == 0))
/*      */       {
/* 1248 */         if (this.trace) {
/* 1249 */           log.trace("Property " + property.getName() + " is bound to " + xmlModelGroup.kind());
/*      */         }
/* 1251 */         ModelGroupBinding propertyGroup = null;
/* 1252 */         QName groupName = null;
/* 1253 */         if (!"##default".equals(xmlModelGroup.name())) {
/* 1254 */           groupName = new QName(xmlModelGroup.name());
/*      */         }
/* 1256 */         if (groupName != null) {
/* 1257 */           propertyGroup = this.schemaBinding.getGroup(groupName);
/*      */         }
/* 1259 */         if (propertyGroup == null)
/*      */         {
/* 1261 */           if (xmlModelGroup.kind().equals("sequence"))
/*      */           {
/* 1263 */             propertyGroup = new SequenceBinding(this.schemaBinding);
/*      */           }
/* 1265 */           else if (xmlModelGroup.kind().equals("choice"))
/*      */           {
/* 1267 */             propertyGroup = new ChoiceBinding(this.schemaBinding);
/*      */           }
/* 1269 */           else if (xmlModelGroup.kind().equals("all"))
/*      */           {
/* 1271 */             propertyGroup = new AllBinding(this.schemaBinding);
/*      */           }
/*      */           else
/*      */           {
/* 1275 */             throw new IllegalStateException("Unexpected JBossXmlModelGroup.kind=" + xmlModelGroup.kind());
/*      */           }
/*      */ 
/* 1278 */           if (groupName != null)
/*      */           {
/* 1281 */             propertyGroup.setQName(groupName);
/* 1282 */             this.schemaBinding.addGroup(propertyGroup.getQName(), propertyGroup);
/*      */           }
/*      */ 
/* 1285 */           propertyGroup.setSkip(Boolean.FALSE);
/*      */ 
/* 1288 */           BeanInfo propBeanInfo = JBossXBBuilder.configuration.getBeanInfo(propClassInfo);
/* 1289 */           BeanAdapterFactory propBeanAdapterFactory = null;
/*      */           try
/*      */           {
/* 1293 */             BeanInfo propBeanAdapterBuilderInfo = JBossXBBuilder.configuration.getBeanInfo(DefaultBeanAdapterBuilder.class);
/*      */ 
/* 1295 */             BeanAdapterBuilder propBeanAdapterBuilder = (BeanAdapterBuilder)propBeanAdapterBuilderInfo.newInstance();
/*      */ 
/* 1297 */             propBeanAdapterFactory = propBeanAdapterBuilder.newFactory(propBeanInfo, null);
/*      */           }
/*      */           catch (Throwable t)
/*      */           {
/* 1301 */             throw new RuntimeException("Error creating BeanAdapterFactory for " + DefaultBeanAdapterBuilder.class.getName(), t);
/*      */           }
/*      */ 
/* 1304 */           BeanHandler propHandler = new BeanHandler(propBeanInfo.getName(), propBeanAdapterFactory);
/* 1305 */           propertyGroup.setHandler(propHandler);
/*      */ 
/* 1307 */           String[] memberOrder = xmlModelGroup.propOrder();
/* 1308 */           if ((memberOrder.length == 0) || (memberOrder[0].length() == 0))
/*      */           {
/* 1310 */             List propNames = new ArrayList();
/* 1311 */             for (PropertyInfo prop : propBeanInfo.getProperties())
/*      */             {
/* 1313 */               propNames.add(prop.getName());
/*      */             }
/* 1315 */             memberOrder = (String[])propNames.toArray(new String[propNames.size()]);
/*      */           }
/*      */ 
/* 1318 */           if (this.trace) {
/* 1319 */             log.trace("Property order for " + xmlModelGroup.kind() + " property " + property.getName() + ": " + Arrays.asList(memberOrder));
/*      */           }
/*      */ 
/* 1323 */           for (String memberPropName : memberOrder)
/*      */           {
/* 1325 */             if ("class".equals(memberPropName))
/*      */             {
/*      */               continue;
/*      */             }
/*      */ 
/* 1330 */             PropertyInfo memberProp = propBeanInfo.getProperty(memberPropName);
/* 1331 */             TypeInfo memberTypeInfo = memberProp.getType();
/* 1332 */             String memberNamespace = null;
/*      */ 
/* 1334 */             JBossXmlNsPrefix nsPrefix = (JBossXmlNsPrefix)memberProp.getUnderlyingAnnotation(JBossXmlNsPrefix.class);
/* 1335 */             if (nsPrefix != null)
/*      */             {
/* 1337 */               memberNamespace = this.schemaBinding.getNamespace(nsPrefix.prefix());
/* 1338 */               if ((memberNamespace == null) && (nsPrefix.schemaTargetIfNotMapped()))
/*      */               {
/* 1340 */                 throw new IllegalStateException("Prefix '" + nsPrefix.prefix() + "' is not mapped to any namespace!");
/*      */               }
/*      */ 
/*      */             }
/*      */ 
/* 1345 */             String memberName = null;
/* 1346 */             XmlElement memberXmlElement = (XmlElement)memberProp.getUnderlyingAnnotation(XmlElement.class);
/* 1347 */             if (memberXmlElement != null)
/*      */             {
/* 1349 */               if (!XmlElement.DEFAULT.class.equals(memberXmlElement.type()))
/*      */               {
/* 1351 */                 memberTypeInfo = memberTypeInfo.getTypeInfoFactory().getTypeInfo(memberXmlElement.type());
/*      */               }
/*      */ 
/* 1354 */               if (memberNamespace == null)
/* 1355 */                 memberNamespace = memberXmlElement.namespace();
/* 1356 */               memberName = memberXmlElement.name();
/*      */             }
/*      */ 
/* 1359 */             if (memberNamespace == null)
/*      */             {
/* 1361 */               memberNamespace = this.defaultNamespace;
/*      */             }
/*      */ 
/* 1364 */             boolean isCol = false;
/* 1365 */             AbstractPropertyHandler memberPropertyHandler = null;
/* 1366 */             if (memberProp.getType().isCollection())
/*      */             {
/* 1368 */               memberPropertyHandler = new CollectionPropertyHandler(memberProp, memberProp.getType());
/* 1369 */               isCol = true;
/*      */ 
/* 1371 */               if ((memberXmlElement == null) || (XmlElement.DEFAULT.class.equals(memberXmlElement.type())))
/*      */               {
/* 1373 */                 JBossXmlCollection jbossXmlCollection = (JBossXmlCollection)memberProp.getUnderlyingAnnotation(JBossXmlCollection.class);
/*      */ 
/* 1375 */                 if (jbossXmlCollection != null)
/*      */                 {
/* 1377 */                   memberTypeInfo = memberTypeInfo.getTypeInfoFactory().getTypeInfo(jbossXmlCollection.type());
/*      */                 }
/* 1379 */                 memberTypeInfo = findComponentType((ClassInfo)memberTypeInfo);
/*      */               }
/*      */ 
/*      */             }
/* 1383 */             else if (memberTypeInfo.isCollection())
/*      */             {
/* 1385 */               memberPropertyHandler = new CollectionPropertyHandler(memberProp, memberTypeInfo);
/* 1386 */               isCol = true;
/* 1387 */               memberTypeInfo = findComponentType((ClassInfo)memberTypeInfo);
/*      */             }
/*      */             else
/*      */             {
/* 1391 */               memberPropertyHandler = new PropertyHandler(memberProp, memberTypeInfo);
/*      */             }
/*      */ 
/* 1394 */             QName memberQName = generateXmlName(memberProp.getName(), this.elementForm, memberNamespace, memberName);
/* 1395 */             propBeanAdapterFactory.addProperty(memberQName, memberPropertyHandler);
/*      */ 
/* 1397 */             XBValueAdapter valueAdapter = null;
/* 1398 */             XmlJavaTypeAdapter xmlTypeAdapter = (XmlJavaTypeAdapter)memberProp.getUnderlyingAnnotation(XmlJavaTypeAdapter.class);
/* 1399 */             if (xmlTypeAdapter != null)
/*      */             {
/* 1401 */               valueAdapter = new XBValueAdapter(xmlTypeAdapter.value(), memberTypeInfo.getTypeInfoFactory());
/* 1402 */               memberTypeInfo = valueAdapter.getAdaptedTypeInfo();
/*      */             }
/*      */ 
/* 1405 */             TypeBinding memberTypeBinding = resolveTypeBinding(memberTypeInfo);
/* 1406 */             ElementBinding memberElement = createElementBinding(memberTypeInfo, memberTypeBinding, memberQName, false);
/*      */ 
/* 1408 */             memberElement.setNillable(true);
/* 1409 */             memberElement.setValueAdapter(valueAdapter);
/* 1410 */             ParticleBinding memberParticle = new ParticleBinding(memberElement, 0, 1, isCol);
/* 1411 */             propertyGroup.addParticle(memberParticle);
/*      */ 
/* 1413 */             if (this.trace) {
/* 1414 */               log.trace("added " + memberParticle + " to " + xmlModelGroup.kind() + ", property " + property.getName());
/*      */             }
/*      */           }
/*      */         }
/*      */ 
/* 1419 */         model.addParticle(new ParticleBinding(propertyGroup));
/*      */ 
/* 1423 */         AbstractPropertyHandler propertyHandler = null;
/* 1424 */         if (propertyType.isCollection()) {
/* 1425 */           propertyHandler = new CollectionPropertyHandler(property, propClassInfo);
/*      */         }
/*      */         else {
/* 1428 */           propertyHandler = new PropertyHandler(property, propClassInfo);
/*      */         }
/* 1430 */         beanAdapterFactory.addProperty(propertyGroup.getQName(), propertyHandler);
/* 1431 */         return;
/*      */       }
/*      */ 
/*      */     }
/*      */ 
/* 1436 */     XmlElement[] elements = null;
/* 1437 */     XmlElement xmlElement = (XmlElement)property.getUnderlyingAnnotation(XmlElement.class);
/* 1438 */     if (xmlElement != null)
/*      */     {
/* 1441 */       elements = new XmlElement[] { xmlElement };
/*      */     }
/*      */     else
/*      */     {
/* 1447 */       XmlElements xmlElements = (XmlElements)property.getUnderlyingAnnotation(XmlElements.class);
/* 1448 */       if (xmlElements != null) {
/* 1449 */         elements = xmlElements.value();
/*      */       }
/*      */     }
/*      */ 
/* 1453 */     if ((elements == null) || (elements.length == 0)) {
/* 1454 */       elements = new XmlElement[1];
/*      */     }
/*      */ 
/* 1457 */     JBossXmlNsPrefix xmlNsPrefix = (JBossXmlNsPrefix)property.getUnderlyingAnnotation(JBossXmlNsPrefix.class);
/*      */ 
/* 1461 */     XmlElementWrapper xmlWrapper = (XmlElementWrapper)property.getUnderlyingAnnotation(XmlElementWrapper.class);
/* 1462 */     if (xmlWrapper != null)
/*      */     {
/* 1464 */       String wrapperNamespace = xmlWrapper.namespace();
/* 1465 */       String wrapperName = xmlWrapper.name();
/* 1466 */       boolean wrapperNillable = xmlWrapper.nillable();
/*      */ 
/* 1468 */       QName wrapperQName = generateXmlName(property.getName(), this.elementForm, wrapperNamespace, wrapperName);
/*      */ 
/* 1470 */       TypeBinding wrapperType = new TypeBinding();
/* 1471 */       SequenceBinding seq = new SequenceBinding(this.schemaBinding);
/* 1472 */       seq.setHandler(BuilderParticleHandler.INSTANCE);
/* 1473 */       ParticleBinding particle = new ParticleBinding(seq);
/* 1474 */       wrapperType.setParticle(particle);
/* 1475 */       wrapperType.setHandler(new DefaultElementHandler());
/*      */ 
/* 1477 */       ElementBinding wrapperElement = createElementBinding(propertyType, wrapperType, wrapperQName, false);
/* 1478 */       wrapperElement.setNillable(wrapperNillable);
/* 1479 */       wrapperElement.setSkip(Boolean.TRUE);
/* 1480 */       particle = new ParticleBinding(wrapperElement, 1, 1, false);
/* 1481 */       localModel.addParticle(particle);
/*      */ 
/* 1483 */       localModel = seq;
/*      */ 
/* 1485 */       if (this.trace) {
/* 1486 */         log.trace("Added property " + wrapperQName + " for type=" + property.getBeanInfo().getName() + " property=" + property.getName() + " as a wrapper element");
/*      */       }
/*      */ 
/*      */     }
/*      */ 
/* 1491 */     if (elements.length > 1)
/*      */     {
/* 1493 */       ChoiceBinding choice = new ChoiceBinding(this.schemaBinding);
/* 1494 */       choice.setHandler(BuilderParticleHandler.INSTANCE);
/* 1495 */       ParticleBinding particleBinding = new ParticleBinding(choice);
/* 1496 */       particleBinding.setMinOccurs(0);
/* 1497 */       particleBinding.setMaxOccurs(1);
/* 1498 */       localModel.addParticle(particleBinding);
/* 1499 */       localModel = choice;
/* 1500 */       if (this.trace) {
/* 1501 */         log.trace("XmlElements seen adding choice for type=" + property.getBeanInfo().getName() + " property=" + property.getName());
/*      */       }
/*      */     }
/*      */ 
/* 1505 */     for (int i = 0; i < elements.length; i++)
/*      */     {
/* 1507 */       XmlElement element = elements[i];
/* 1508 */       if (this.trace) {
/* 1509 */         log.trace("Processing " + element + " for type=" + property.getBeanInfo().getName() + " property=" + property.getName());
/*      */       }
/*      */ 
/* 1513 */       String overrideNamespace = null;
/* 1514 */       String overrideName = null;
/* 1515 */       boolean nillable = false;
/* 1516 */       boolean required = false;
/*      */ 
/* 1518 */       TypeInfo localPropertyType = propertyType;
/*      */ 
/* 1520 */       if (element != null)
/*      */       {
/* 1522 */         overrideNamespace = element.namespace();
/* 1523 */         overrideName = element.name();
/* 1524 */         nillable = element.nillable();
/* 1525 */         required = element.required();
/* 1526 */         Class elementType = element.type();
/* 1527 */         if (elementType != XmlElement.DEFAULT.class) {
/* 1528 */           localPropertyType = propertyType.getTypeInfoFactory().getTypeInfo(elementType);
/*      */         }
/*      */       }
/* 1531 */       if (xmlNsPrefix != null)
/*      */       {
/* 1533 */         overrideNamespace = this.schemaBinding.getNamespace(xmlNsPrefix.prefix());
/* 1534 */         if (overrideNamespace == null)
/*      */         {
/* 1536 */           if (xmlNsPrefix.schemaTargetIfNotMapped())
/*      */           {
/* 1538 */             overrideNamespace = this.defaultNamespace;
/*      */           }
/*      */           else
/*      */           {
/* 1542 */             throw new IllegalStateException("Prefix '" + xmlNsPrefix.prefix() + "' is not mapped to any namespace!");
/*      */           }
/*      */ 
/*      */         }
/*      */ 
/*      */       }
/*      */ 
/* 1549 */       QName qName = generateXmlName(property.getName(), this.elementForm, overrideNamespace, overrideName);
/*      */ 
/* 1552 */       JBossXmlGroup jbossXmlGroup = null;
/* 1553 */       if (!propertyType.isPrimitive())
/* 1554 */         jbossXmlGroup = (JBossXmlGroup)((ClassInfo)propertyType).getUnderlyingAnnotation(JBossXmlGroup.class);
/* 1555 */       if ((element == null) && (jbossXmlGroup != null))
/*      */       {
/* 1557 */         if (this.trace) {
/* 1558 */           log.trace("Processing group for property " + property.getName() + " in " + property.getBeanInfo().getName() + " " + jbossXmlGroup);
/*      */         }
/* 1560 */         JBossXmlChild[] children = jbossXmlGroup.value();
/* 1561 */         if ((children != null) && (children.length > 0))
/*      */         {
/* 1563 */           TypeBinding elementTypeBinding = new TypeBinding();
/* 1564 */           elementTypeBinding.setSchemaBinding(this.schemaBinding);
/* 1565 */           elementTypeBinding.setHandler(BuilderParticleHandler.INSTANCE);
/* 1566 */           ElementBinding elementBinding = createElementBinding(localPropertyType, elementTypeBinding, qName, false);
/*      */ 
/* 1569 */           ParticleBinding particle = new ParticleBinding(elementBinding, 1, 1, false);
/* 1570 */           if (!required)
/* 1571 */             particle.setMinOccurs(0);
/* 1572 */           localModel.addParticle(particle);
/*      */ 
/* 1575 */           JBossXmlGroupText groupText = (JBossXmlGroupText)((ClassInfo)propertyType).getUnderlyingAnnotation(JBossXmlGroupText.class);
/*      */ 
/* 1577 */           if (groupText != null)
/*      */           {
/*      */             CharactersHandler textHandler;
/*      */             CharactersHandler textHandler;
/* 1580 */             if (groupText.wrapper() != Object.class)
/*      */             {
/* 1582 */               BeanInfo wrapperInfo = JBossXBBuilder.configuration.getBeanInfo(groupText.wrapper());
/* 1583 */               textHandler = new ValueHandler(property, wrapperInfo, groupText.property());
/*      */             }
/*      */             else {
/* 1586 */               textHandler = new ValueHandler(property);
/* 1587 */             }elementTypeBinding.setSimpleType(textHandler);
/*      */           }
/*      */ 
/* 1591 */           ChoiceBinding childModel = new ChoiceBinding(this.schemaBinding);
/* 1592 */           childModel.setHandler(BuilderParticleHandler.INSTANCE);
/* 1593 */           ParticleBinding particleBinding = new ParticleBinding(childModel);
/* 1594 */           particleBinding.setMinOccurs(0);
/* 1595 */           particleBinding.setMaxOccurs(1);
/* 1596 */           elementTypeBinding.setParticle(particleBinding);
/*      */ 
/* 1598 */           for (JBossXmlChild child : children)
/*      */           {
/* 1600 */             QName childName = generateXmlName(child.name(), this.elementForm, child.namespace(), child.name());
/* 1601 */             TypeInfo childType = JBossXBBuilder.configuration.getTypeInfo(child.type());
/*      */ 
/* 1603 */             TypeBinding childTypeBinding = resolveTypeBinding(childType);
/* 1604 */             ElementBinding childBinding = createElementBinding(childType, childTypeBinding, childName, false);
/* 1605 */             childBinding.setNillable(nillable);
/*      */ 
/* 1608 */             particle = new ParticleBinding(childBinding, child.minOccurs(), child.maxOccurs(), child.unbounded());
/* 1609 */             particle.setMinOccurs(0);
/* 1610 */             childModel.addParticle(particle);
/*      */ 
/* 1612 */             DefaultElementInterceptor interceptor = new PropertyInterceptor(property, propertyType);
/* 1613 */             elementTypeBinding.pushInterceptor(childName, interceptor);
/* 1614 */             if (this.trace) {
/* 1615 */               log.trace("Added interceptor " + childName + " for type=" + property.getBeanInfo().getName() + " property=" + property.getName() + " interceptor=" + interceptor);
/*      */             }
/*      */ 
/* 1618 */             beanAdapterFactory.addProperty(qName, new NoopPropertyHandler(property, propertyType));
/*      */ 
/* 1620 */             JBossXmlGroupWildcard groupWildcard = (JBossXmlGroupWildcard)((ClassInfo)propertyType).getUnderlyingAnnotation(JBossXmlGroupWildcard.class);
/*      */ 
/* 1623 */             if (groupWildcard == null)
/*      */               continue;
/*      */             ChildWildcardHandler groupWildcardHandler;
/*      */             ChildWildcardHandler groupWildcardHandler;
/* 1626 */             if (groupWildcard.wrapper() != Object.class)
/*      */             {
/* 1628 */               BeanInfo wrapperInfo = JBossXBBuilder.configuration.getBeanInfo(groupWildcard.wrapper());
/* 1629 */               groupWildcardHandler = new ChildWildcardHandler(property, wrapperInfo, groupWildcard.property());
/*      */             }
/*      */             else {
/* 1632 */               groupWildcardHandler = new ChildWildcardHandler(property);
/*      */             }
/* 1634 */             WildcardBinding wildcard = new WildcardBinding(this.schemaBinding);
/* 1635 */             if (groupWildcard.lax())
/* 1636 */               wildcard.setProcessContents(3);
/*      */             else {
/* 1638 */               wildcard.setProcessContents(1);
/*      */             }
/* 1640 */             particleBinding = new ParticleBinding(wildcard);
/* 1641 */             particleBinding.setMinOccurs(0);
/* 1642 */             particleBinding.setMaxOccurs(1);
/* 1643 */             childModel.addParticle(particleBinding);
/*      */ 
/* 1645 */             elementTypeBinding.getWildcard().setWildcardHandler(groupWildcardHandler);
/*      */           }
/*      */         }
/*      */ 
/*      */       }
/*      */       else
/*      */       {
/* 1652 */         XBValueAdapter valueAdapter = null;
/* 1653 */         XmlJavaTypeAdapter xmlTypeAdapter = (XmlJavaTypeAdapter)property.getUnderlyingAnnotation(XmlJavaTypeAdapter.class);
/* 1654 */         if (xmlTypeAdapter != null)
/*      */         {
/* 1656 */           valueAdapter = new XBValueAdapter(xmlTypeAdapter.value(), propertyType.getTypeInfoFactory());
/* 1657 */           localPropertyType = valueAdapter.getAdaptedTypeInfo();
/*      */         }
/*      */ 
/* 1660 */         ModelGroupBinding targetGroup = localModel;
/* 1661 */         boolean isCol = false;
/* 1662 */         AbstractPropertyHandler propertyHandler = null;
/*      */ 
/* 1666 */         if ((propertyType.isCollection()) && (((ClassInfo)propertyType).getUnderlyingAnnotation(XmlType.class) == null))
/*      */         {
/* 1669 */           isCol = true;
/* 1670 */           propertyHandler = new CollectionPropertyHandler(property, propertyType);
/* 1671 */           ClassInfo typeArg = (ClassInfo)findComponentType(property);
/*      */ 
/* 1674 */           if ((typeArg != null) && (typeArg.getUnderlyingAnnotation(JBossXmlModelGroup.class) == null))
/*      */           {
/* 1678 */             JBossXmlChild xmlChild = (JBossXmlChild)((ClassInfo)propertyType).getUnderlyingAnnotation(JBossXmlChild.class);
/* 1679 */             if ((xmlChild == null) && (localPropertyType.equals(propertyType)))
/*      */             {
/* 1681 */               localPropertyType = typeArg;
/*      */             }
/*      */ 
/*      */           }
/*      */ 
/*      */         }
/* 1687 */         else if ((localPropertyType.isCollection()) && (((ClassInfo)localPropertyType).getUnderlyingAnnotation(XmlType.class) == null))
/*      */         {
/*      */           Type parameterizedType;
/*      */           Type parameterizedType;
/* 1691 */           if (valueAdapter != null)
/*      */           {
/* 1693 */             propertyHandler = new PropertyHandler(property, localPropertyType);
/* 1694 */             parameterizedType = valueAdapter.getAdaptedType();
/*      */           }
/*      */           else
/*      */           {
/* 1698 */             propertyHandler = new CollectionPropertyHandler(property, localPropertyType);
/* 1699 */             parameterizedType = localPropertyType.getType();
/*      */           }
/* 1701 */           isCol = true;
/* 1702 */           localPropertyType = findActualType((ClassInfo)localPropertyType, parameterizedType, Collection.class, 0);
/*      */         }
/*      */         else
/*      */         {
/* 1707 */           propertyHandler = new PropertyHandler(property, localPropertyType);
/*      */         }
/*      */ 
/* 1713 */         if (!Element.class.getName().equals(propertyType.getName()))
/*      */         {
/* 1715 */           TypeBinding elementTypeBinding = resolveTypeBinding(localPropertyType);
/* 1716 */           ElementBinding elementBinding = createElementBinding(localPropertyType, elementTypeBinding, qName, false);
/* 1717 */           elementBinding.setNillable(nillable);
/* 1718 */           elementBinding.setValueAdapter(valueAdapter);
/*      */ 
/* 1721 */           ParticleBinding particle = new ParticleBinding(elementBinding, 1, 1, isCol);
/* 1722 */           if (!required) {
/* 1723 */             particle.setMinOccurs(0);
/*      */           }
/* 1725 */           targetGroup.addParticle(particle);
/*      */         }
/*      */ 
/* 1728 */         beanAdapterFactory.addProperty(qName, propertyHandler);
/* 1729 */         if (this.trace)
/* 1730 */           log.trace("Added property " + qName + " for type=" + property.getBeanInfo().getName() + " property=" + property.getName() + " handler=" + propertyHandler);

View Full Code Here

/*      */     {
/*  408 */       TypeBinding type = ((ElementBinding)term).getType();
/*  409 */       if (type.getAttributes().isEmpty())
/*      */       {
/*  411 */         ParticleBinding typeParticle = type.getParticle();
/*  412 */         ModelGroupBinding modelGroup = (ModelGroupBinding)(typeParticle == null ? null : typeParticle.getTerm());
/*  413 */         arrayItem = modelGroup == null ? null : modelGroup.getArrayItem();
/*      */ 
/*  416 */         if ((arrayItem != null) && ((arrayItem.isSkip()) || (arrayItem.getMapEntryMetaData() != null) || (arrayItem.getPutMethodMetaData() != null) || (arrayItem.getAddMethodMetaData() != null)))
/*      */         {
/*  423 */           arrayItem = null;
/*      */         }

View Full Code Here

/*      */     {
/*  829 */       ElementBinding arrayItem = null;
/*  830 */       if ((!type.isSimple()) && (type.getAttributes().isEmpty()))
/*      */       {
/*  832 */         ParticleBinding typeParticle = type.getParticle();
/*  833 */         ModelGroupBinding modelGroup = (ModelGroupBinding)(typeParticle == null ? null : typeParticle.getTerm());
/*  834 */         arrayItem = modelGroup == null ? null : modelGroup.getArrayItem();
/*      */       }
/*      */ 
/*  837 */       if (arrayItem != null)
/*      */       {
/*  839 */         Class cls = classForElement(arrayItem, parentClass);

View Full Code Here

         log.trace("PropertyOrder " + Arrays.asList(propertyOrder) + " for type=" + beanInfo.getName());


      // Determine the model
      // TODO simple types/content when no properties other than @XmlValue and @XmlAttribute
      typeBinding.setSimple(false);
      ModelGroupBinding model = null;
      boolean propOrderMissing = propertyNames.size() > 1 && determinePropertyOrder && accessOrder == XmlAccessOrder.UNDEFINED;
      if(jbossXmlType != null && !JBossXmlConstants.DEFAULT.equals(jbossXmlType.modelGroup()))
         model = createModelGroup(jbossXmlType.modelGroup(), typeInfo, propOrderMissing, propertyOrder);
      else if (allBinding)
         model = new AllBinding(schemaBinding);
      else
      {
         if(propOrderMissing)
            assertPropOrderNotRequired(typeInfo, propertyOrder);
         model = groupFactory.createSequence(schemaBinding);
      }
      
      if (trace)
         log.trace(model.getGroupType() + " model group for type=" + beanInfo.getName());


      model.setHandler(BuilderParticleHandler.INSTANCE);
      ParticleBinding typeParticle = new ParticleBinding(model);
      typeParticle.setMinOccurs(1);
      typeParticle.setMaxOccurs(1);
      typeBinding.setParticle(typeParticle);


      if (typeInfo.isCollection())
      {
         typeParticle.setMinOccurs(0);
         typeParticle.setMaxOccursUnbounded(true);
/*         TypeInfo memberBaseType = typeInfo.getComponentType();


         JBossXmlModelGroup xmlModelGroup = ((ClassInfo) memberBaseType).getUnderlyingAnnotation(JBossXmlModelGroup.class);
         if (xmlModelGroup != null)
         {
            bindParticlesModelGroup(typeBinding, model, memberBaseType, xmlModelGroup, true, beanAdapterFactory, null);
         }
*/      }


      // Determine the wildcard handler
      AbstractPropertyHandler wildcardHandler = null;
      if (wildcardProperty != null)
      {
         TypeInfo wildcardType = wildcardProperty.getType();
         if (wildcardType.isCollection())
            wildcardHandler = new CollectionPropertyWildcardHandler(wildcardProperty, wildcardType);
         else
            wildcardHandler = new PropertyWildcardHandler(wildcardProperty, wildcardType);
      }


      // Look through the properties
      for (String name : propertyOrder)
      {
         // propertyOrder is initialized to {""}
         if(name.length() == 0)
            continue;
         // Setup the error stack
         push(typeInfo, name);
         // Get the property
         PropertyInfo property = beanInfo.getProperty(name);
         bindProperty(property, model, beanAdapterFactory, propertyOrder, property == wildcardProperty);
         pop();
      }


      // Bind the children
      JBossXmlChild[] children = null;
      JBossXmlChildren jbossXmlChildren = typeInfo.getUnderlyingAnnotation(JBossXmlChildren.class);
      if (jbossXmlChildren != null)
         children = jbossXmlChildren.value();
      else
      {
         JBossXmlChild jbossXmlChild = typeInfo.getUnderlyingAnnotation(JBossXmlChild.class);
         if (jbossXmlChild != null)
            children = new JBossXmlChild[] { jbossXmlChild };
      }


      if (children != null && children.length > 0)
      {
         for (JBossXmlChild child : children)
         {
            QName qName = generateXmlName(child.name(), elementForm, child.namespace(), child.name());
            TypeInfo childType = JBossXBBuilder.configuration.getTypeInfo(child.type());


            TypeBinding elementTypeBinding = resolveTypeBinding(childType);
            ElementBinding elementBinding = createElementBinding(childType, elementTypeBinding, qName, false);


            // Bind it to the model
            ParticleBinding particle = new ParticleBinding(elementBinding, child.minOccurs(), child.maxOccurs(), child.unbounded());
            model.addParticle(particle);


            if(childType.isMap())
               bindMapProperty(null, (ClassInfo) childType, elementTypeBinding.getQName(), (ModelGroupBinding) elementTypeBinding.getParticle().getTerm());
            
            DefaultElementInterceptor interceptor = null;
            if (typeInfo.isCollection())
               interceptor = ChildCollectionInterceptor.SINGLETON;
            else
            {
               // Expect a type with a value property to accept the child value
               PropertyInfo property = beanInfo.getProperty("value");
               if (property == null)
                  throw new UnsupportedOperationException("Expected a value property for non-collection type with JBossXmlChildren");
               TypeInfo propertyType = property.getType();
               interceptor = new PropertyInterceptor(property, propertyType);
            }
            typeBinding.pushInterceptor(qName, interceptor);
            if (trace)
               log.trace("Added interceptor " + qName + " for type=" + childType + " interceptor=" + interceptor);
         }
      }


      // Bind the wildcard
      if (wildcardProperty != null)
      {
         if (trace)
            log.trace("Processing WildcardProperty for type=" + beanInfo.getName() + " property=" + wildcardProperty.getName());
         ModelGroupBinding localModel = model;
         TypeInfo wildcardType = wildcardProperty.getType();
         TypeInfo type = wildcardType;


         // Setup any new model and determine the wildcard type
         if (wildcardType.isArray())
         {
            localModel = createArray(localModel);
            type = ((ArrayInfo) wildcardType).getComponentType();
            if (trace)
               log.trace("Wildcard " + wildcardProperty.getName() + " is an array of type " + type.getName());
         }
         else if (wildcardType.isCollection())
         {
            localModel = createCollection(localModel);
            type = ((ClassInfo)wildcardProperty.getType()).getComponentType();
            if (trace)
               log.trace("Wildcard " + wildcardProperty.getName() + " is a collection of type " + type.getName());
         }


         XmlAnyElement xmlAnyElement = wildcardProperty.getUnderlyingAnnotation(XmlAnyElement.class);
         boolean isLax = xmlAnyElement == null ? true : xmlAnyElement.lax();
         WildcardBinding wildcard = new WildcardBinding(schemaBinding);
         if (isLax)
            wildcard.setProcessContents((short) 3); // Lax
         else
            wildcard.setProcessContents((short) 1); // Strict


         // Dom element?
         if (Element.class.getName().equals(type.getName()))
         {
            wildcard.setUnresolvedElementHandler(DOMHandler.INSTANCE);
            wildcard.setUnresolvedCharactersHandler(DOMHandler.INSTANCE);
         }


         // Bind the particle to the model
         ParticleBinding particleBinding = new ParticleBinding(wildcard);
         particleBinding.setMinOccurs(0);
         particleBinding.setMaxOccurs(1);
         localModel.addParticle(particleBinding);
         typeBinding.getWildcard().setWildcardHandler((ParticleHandler) wildcardHandler);
         beanAdapterFactory.setWildcardHandler(wildcardHandler);
      }


      JBossXmlChildWildcard childWildcard = typeInfo.getUnderlyingAnnotation(JBossXmlChildWildcard.class);

View Full Code Here

      if (xmlTransient != null && propertyOrder != null)
         throw new RuntimeException("Property " + property.getName() + " in property order "
               + Arrays.asList(propertyOrder) + " is marked @XmlTransient");


      // The current model
      ModelGroupBinding localModel = parentModel;


      TypeInfo propertyComponentType = propertyType;
      XmlType propertyXmlType = null;
      JBossXmlModelGroup propertyXmlModelGroup = null;
      // Setup any new model
      if (propertyType.isArray())
      {
         if (trace)
            log.trace("Property " + property.getName() + " is an array");
         localModel = createArray(localModel);
      }
      else if (propertyType.isCollection())
      {
         if (trace)
            log.trace("Property " + property.getName() + " is a collection");
         JBossXmlCollection xmlCol = property.getUnderlyingAnnotation(JBossXmlCollection.class);
         if (xmlCol != null)
         {
            // this is the type that should be analyzed
            propertyType = propertyType.getTypeInfoFactory().getTypeInfo(xmlCol.type());
         }
         ClassInfo propertyClassInfo = (ClassInfo)propertyType;
         propertyXmlType = propertyClassInfo.getUnderlyingAnnotation(XmlType.class);
         propertyComponentType = propertyClassInfo.getComponentType();
      }


      // Is this property bound to a model group
      if (!propertyComponentType.isPrimitive())
      {
         ClassInfo componentClass = (ClassInfo) propertyComponentType;


         // TODO XmlElement on this property?..
         //XmlElement propXmlElement = property.getUnderlyingAnnotation(XmlElement.class);
         //if (propXmlElement != null)
         //   propClassInfo = (ClassInfo) propClassInfo.getTypeInfoFactory().getTypeInfo(propXmlElement.type());
         
         // if it's a model group then 
         propertyXmlModelGroup = componentClass.getUnderlyingAnnotation(JBossXmlModelGroup.class);
         if (propertyXmlType == null && propertyXmlModelGroup != null)
         {
            // model group value handler based on the model group name
            // TODO what if it doesn't have a name?
            AbstractPropertyHandler propertyHandler = null;
            if (propertyType.isCollection())
               propertyHandler = new CollectionPropertyHandler(property, propertyType);
            else
               propertyHandler = new PropertyHandler(property, propertyType);
            bindModelGroup(propertyXmlModelGroup, property, beanAdapterFactory, propertyHandler, null, localModel);
            return;
         }
      }


      // So this is element(s)
      XmlElement[] elements = null;
      XmlElement xmlElement = property.getUnderlyingAnnotation(XmlElement.class);
      if (xmlElement != null)
      {
         // A single element annotated
         elements = new XmlElement[]{xmlElement};
      }
      else
      {
         // Mutlple elements
         XmlElements xmlElements = property.getUnderlyingAnnotation(XmlElements.class);
         if (xmlElements != null)
            elements = xmlElements.value();
      }


      // A single element not annotated
      if (elements == null || elements.length == 0)
         elements = new XmlElement[1];


      // support for @XmlElementWrapper
      // the wrapping element is ignored in this case
      XmlElementWrapper xmlWrapper = property.getUnderlyingAnnotation(XmlElementWrapper.class);
      if (xmlWrapper != null)
      {         
         String wrapperNamespace = xmlWrapper.namespace();
         String wrapperName = xmlWrapper.name();
         QName wrapperQName = generateXmlName(property.getName(), elementForm, wrapperNamespace, wrapperName);
         localModel = bindXmlElementWrapper(propertyType, localModel, xmlWrapper, wrapperQName);
         beanAdapterFactory.addProperty(wrapperQName, new PropertyHandler(property, propertyType));
         if (trace)
            log.trace("Added property " + wrapperQName + " for type=" + property.getBeanInfo().getName() + " property="
                  + property.getName() + " as a wrapper element");
      }


      // Setup a choice
      if (elements.length > 1)
      {
         ChoiceBinding choice = new ChoiceBinding(schemaBinding);
         choice.setHandler(BuilderParticleHandler.INSTANCE);
         ParticleBinding particleBinding = new ParticleBinding(choice);
         particleBinding.setMinOccurs(0);
         particleBinding.setMaxOccursUnbounded(true);
         localModel.addParticle(particleBinding);
         localModel = choice;
         if (trace)
            log.trace("XmlElements seen adding choice for type=" + property.getBeanInfo().getName() + " property=" + property.getName());
      }


      for (int i = 0; i < elements.length; ++i)
      {
         XmlElement element = elements[i];
         if (trace)
            log.trace("Processing " + element + " for type=" + property.getBeanInfo().getName() + " property=" + property.getName());


         // Determine the parameters
         String overrideNamespace = null;
         String overrideName = null;
         boolean nillable = false;
         boolean required = false;


         TypeInfo localPropertyType = propertyType;


         if (element != null)
         {
            overrideNamespace = element.namespace();
            overrideName = element.name();
            nillable = element.nillable();
            required = element.required();
            Class<?> elementType = element.type();
            if (elementType != XmlElement.DEFAULT.class)
               localPropertyType = propertyType.getTypeInfoFactory().getTypeInfo(elementType);
         }


         // for now support just one JBossXmlNsPrefix
         String prefixNs = null;
         JBossXmlNsPrefix xmlNsPrefix = property.getUnderlyingAnnotation(JBossXmlNsPrefix.class);
         String overridenDefaultNamespace = defaultNamespace;
         try
         {
         if (xmlNsPrefix != null)
         {
            prefixNs = schemaBinding.getNamespace(xmlNsPrefix.prefix());
            if (prefixNs == null)
            {
               if (xmlNsPrefix.schemaTargetIfNotMapped())
                  prefixNs = defaultNamespace;
               else
                  throw new IllegalStateException("Prefix '" + xmlNsPrefix.prefix() + "' is not mapped to any namespace!");
            }
            
            if(xmlNsPrefix.applyToComponentQName())
               overrideNamespace = prefixNs;
         }


         // Determine the name
         QName propertyQName = generateXmlName(property.getName(), elementForm, overrideNamespace, overrideName);


         if(prefixNs != null && xmlNsPrefix.applyToComponentContent())
            defaultNamespace = prefixNs;


         // Create the element
         JBossXmlGroup jbossXmlGroup = null;
         if (!propertyType.isPrimitive())
            jbossXmlGroup = ((ClassInfo) propertyType).getUnderlyingAnnotation(JBossXmlGroup.class);
         if (element == null && jbossXmlGroup != null)
         {
            if (trace)
               log.trace("Processing group for property " + property.getName() + " in "
                     + property.getBeanInfo().getName() + " " + jbossXmlGroup);


            JBossXmlChild[] children = jbossXmlGroup.value();
            if (children != null && children.length > 0)
            {
               TypeBinding elementTypeBinding = new TypeBinding();
               JBossXmlGroupText groupText = ((ClassInfo) propertyType).getUnderlyingAnnotation(JBossXmlGroupText.class);
               if (groupText != null && groupText.wrapper() != Object.class)
               {
                  BeanInfo wrapperInfo = JBossXBBuilder.configuration.getBeanInfo(groupText.wrapper());
                  TypeBinding wrapperTypeBinding = resolveTypeBinding(wrapperInfo.getClassInfo());
                  // Steal the attributes
                  Collection<AttributeBinding> otherAttributes = wrapperTypeBinding.getAttributes();
                  if (otherAttributes != null)
                  {
                     for (AttributeBinding other : otherAttributes)
                        elementTypeBinding.addAttribute(other);
                  }
                  ParticleHandler particleHandler = wrapperTypeBinding.getHandler();
                  if (particleHandler instanceof BeanHandler == false)
                     throw new IllegalStateException("Cannot wrap " + wrapperInfo.getName() + " not a bean type " + particleHandler);
                  BeanHandler beanHandler = (BeanHandler) particleHandler;
                  WrapperBeanAdapterFactory wrapperFactory = new WrapperBeanAdapterFactory(beanHandler.getBeanAdapterFactory(), propertyType.getType());
                  elementTypeBinding.setHandler(new BeanHandler(wrapperInfo.getName(), wrapperFactory));
                  elementTypeBinding.setSimpleType(wrapperTypeBinding.getSimpleType());
               }
               else
               {
                  elementTypeBinding.setHandler(BuilderParticleHandler.INSTANCE);
               }
               elementTypeBinding.setSchemaBinding(schemaBinding);
               ElementBinding elementBinding = createElementBinding(localPropertyType, elementTypeBinding, propertyQName, false);


               // Bind it to the model
               ParticleBinding particle = new ParticleBinding(elementBinding, 1, 1, false);
               if (required == false)
                  particle.setMinOccurs(0);
               localModel.addParticle(particle);


               // Setup the child model
               ChoiceBinding childModel = new ChoiceBinding(schemaBinding);
               childModel.setHandler(BuilderParticleHandler.INSTANCE);
               ParticleBinding particleBinding = new ParticleBinding(childModel);
               particleBinding.setMinOccurs(0);
               particleBinding.setMaxOccurs(1);
               elementTypeBinding.setParticle(particleBinding);


               for (JBossXmlChild child : children)
               {
                  QName childName = generateXmlName(child.name(), elementForm, child.namespace(), child.name());
                  TypeInfo childType = JBossXBBuilder.configuration.getTypeInfo(child.type());


                  TypeBinding childTypeBinding = resolveTypeBinding(childType);
                  ElementBinding childBinding = createElementBinding(childType, childTypeBinding, childName, false);
                  childBinding.setNillable(nillable);


                  // Bind it to the model
                  particle = new ParticleBinding(childBinding, child.minOccurs(), child.maxOccurs(), child.unbounded());
                  particle.setMinOccurs(0);
                  childModel.addParticle(particle);


                  if(childType.isMap())
                     bindMapProperty(property, (ClassInfo) childType, childName, (ModelGroupBinding) childTypeBinding.getParticle().getTerm());
                                    
                  DefaultElementInterceptor interceptor = new PropertyInterceptor(property, propertyType);
                  elementTypeBinding.pushInterceptor(childName, interceptor);
                  if (trace)
                     log.trace("Added interceptor " + childName + " for type=" + property.getBeanInfo().getName()
                           + " property=" + property.getName() + " interceptor=" + interceptor + " " + childType.getName());


                  beanAdapterFactory.addProperty(propertyQName, new PropertyHandler(property, propertyType));


                  JBossXmlGroupWildcard groupWildcard = ((ClassInfo) propertyType)
                        .getUnderlyingAnnotation(JBossXmlGroupWildcard.class);


                  if (groupWildcard != null)
                  {
                     ChildWildcardHandler groupWildcardHandler;
                     if (groupWildcard.wrapper() != Object.class)
                     {
                        BeanInfo wrapperInfo = JBossXBBuilder.configuration.getBeanInfo(groupWildcard.wrapper());
                        groupWildcardHandler = new ChildWildcardHandler(property, wrapperInfo, groupWildcard.property());
                     }
                     else
                        groupWildcardHandler = new ChildWildcardHandler(property);


                     WildcardBinding wildcard = new WildcardBinding(schemaBinding);
                     if (groupWildcard.lax())
                        wildcard.setProcessContents((short) 3); // Lax
                     else
                        wildcard.setProcessContents((short) 1); // Strict


                     particleBinding = new ParticleBinding(wildcard);
                     particleBinding.setMinOccurs(0);
                     particleBinding.setMaxOccurs(1);
                     childModel.addParticle(particleBinding);


                     elementTypeBinding.getWildcard().setWildcardHandler(groupWildcardHandler);
                  }
               }
            }
         }
         else
         {
            XBValueAdapter valueAdapter = null;
            XmlJavaTypeAdapter xmlTypeAdapter = property.getUnderlyingAnnotation(XmlJavaTypeAdapter.class);
            if (xmlTypeAdapter != null)
            {
               valueAdapter = new XBValueAdapter(xmlTypeAdapter.value(), propertyType.getTypeInfoFactory());
               localPropertyType = valueAdapter.getAdaptedTypeInfo();
            }


            ModelGroupBinding targetGroup = localModel;
            boolean isCol = false;
            boolean isMap = false;
            AbstractPropertyHandler propertyHandler = null;


            // a collection may be bound as a value of a complex type
            // and this is checked with the XmlType annotation
            if (propertyType.isCollection() && ((ClassInfo) propertyType).getUnderlyingAnnotation(XmlType.class) == null)
            {
               isCol = true;
               propertyHandler = new CollectionPropertyHandler(property, propertyType);
               // here we get the comp type based on the non-overriden property type...
               // which feels like a weak point
               TypeInfo typeArg = ((ClassInfo)property.getType()).getComponentType();
               if (typeArg != null)
               {
                  JBossXmlChild xmlChild = ((ClassInfo) propertyType).getUnderlyingAnnotation(JBossXmlChild.class);
                  if (xmlChild == null && localPropertyType.equals(propertyType))
                  {  // the localPropertyType was not overriden previously so use the collection parameter type
                     localPropertyType = typeArg;
                  }
               }
            }
            // TODO this shouldn't be here (because localPropertyType should specify an item?)
            // this is to support the Descriptions.class -> DescriptionsImpl.class
            else if (localPropertyType.isCollection()
                  && ((ClassInfo) localPropertyType).getUnderlyingAnnotation(XmlType.class) == null)
            {
               if (valueAdapter != null)
                  propertyHandler = new PropertyHandler(property, localPropertyType);
               else
                  propertyHandler = new CollectionPropertyHandler(property, localPropertyType);
               isCol = true;
               localPropertyType = ((ClassInfo)localPropertyType).getComponentType();               
            }
            else if (localPropertyType.isMap())
            {
               TypeBinding wrapperType = null;
               if(elements.length > 1)
               {
                  wrapperType = resolveTypeBinding(localPropertyType);
                  ElementBinding elementBinding = createElementBinding(localPropertyType, wrapperType, propertyQName, false);
                  elementBinding.setNillable(nillable);
                  elementBinding.setValueAdapter(valueAdapter);


                  // Bind it to the model
                  ParticleBinding particle = new ParticleBinding(elementBinding, 0, 1, isCol);
                  if (required == false)
                     particle.setMinOccurs(0);


                  targetGroup.addParticle(particle);
                  targetGroup = (ModelGroupBinding) wrapperType.getParticle().getTerm();
               }


               QName boundQName = bindMapProperty(property, (ClassInfo) localPropertyType, propertyQName, targetGroup);
               if(boundQName != null)
               {
                  if(wrapperType != null)
                  {
                     BeanAdapterFactory wrapperBeanFactory = ((BeanHandler)wrapperType.getHandler()).getBeanAdapterFactory();
                     Map<QName, AbstractPropertyHandler> properties = wrapperBeanFactory.getProperties();
                     if(!properties.containsKey(boundQName))
                     {
                        propertyHandler = new MapPropertyHandler(JBossXBBuilder.configuration, property, localPropertyType, true);
                        wrapperBeanFactory.addProperty(boundQName, propertyHandler);
                     }
                     propertyHandler = new PropertyHandler(property, localPropertyType);
                  }
                  else
                  {
                     propertyQName = boundQName;
                     propertyHandler = new MapPropertyHandler(JBossXBBuilder.configuration, property, localPropertyType, false);
                  }
                  isMap = true;
               }
               else
                  propertyHandler = new PropertyHandler(property, localPropertyType);
            }
            else
            {
               propertyHandler = new PropertyHandler(property, localPropertyType);
            }


            ParticleBinding particle;
            if(Element.class.getName().equals(propertyType.getName()))
            {
               if(!wildcardProperty)
               {
                  WildcardBinding wildcard = new WildcardBinding(schemaBinding);
                  wildcard.setProcessContents((short) 2);
                  wildcard.setUnresolvedElementHandler(DOMHandler.INSTANCE);
                  wildcard.setUnresolvedCharactersHandler(DOMHandler.INSTANCE);


                  SequenceBinding seq = new SequenceBinding(schemaBinding);
                  seq.addParticle(new ParticleBinding(wildcard, 0, 1, false));


                  TypeBinding elementTypeBinding = new TypeBinding();
                  elementTypeBinding.setHandler(new NonXmlAnyElementDOMElementPropertyHandler(property, propertyType));
                  elementTypeBinding.setParticle(new ParticleBinding(seq, 0, 1, true));


                  ElementBinding elementBinding = createElementBinding(localPropertyType, elementTypeBinding, propertyQName, false);
                  elementBinding.setNillable(nillable);
                  elementBinding.setValueAdapter(valueAdapter);


                  // Bind it to the model
                  particle = new ParticleBinding(elementBinding, 1, 1, isCol);
                  if (required == false)
                     particle.setMinOccurs(0);


                  targetGroup.addParticle(particle);
               }
            }
            else if (!isMap)
            {
               TypeBinding elementType = resolveTypeBinding(localPropertyType);


               if (propertyXmlModelGroup != null)
                  bindModelGroup(propertyXmlModelGroup, property, null, null, elementType, (ModelGroupBinding) elementType.getParticle().getTerm());


               ElementBinding elementBinding = createElementBinding(localPropertyType, elementType, propertyQName, false);
               elementBinding.setNillable(nillable);
               elementBinding.setValueAdapter(valueAdapter);


               JBossXmlPreserveWhitespace preserveSpace = property.getUnderlyingAnnotation(JBossXmlPreserveWhitespace.class);
               if (preserveSpace != null)
               {
                  elementBinding.setNormalizeSpace(preserveSpace.preserve() ? false : true);
                  if (trace)
                     log.trace("@JBossXmlPreserveWhitespace.preserve=" + preserveSpace.preserve() + " for " + elementBinding.getQName());
               }


               // Bind it to the model
               particle = new ParticleBinding(elementBinding, 1, 1, isCol);
               if (required == false)
                  particle.setMinOccurs(0);


               targetGroup.addParticle(particle);
            }


            beanAdapterFactory.addProperty(propertyQName, propertyHandler);
            if (trace)
               log.trace("Added property " + propertyQName + " for type=" + property.getBeanInfo().getName() + " property="

View Full Code Here


      QName groupName = null;
      if (!JBossXmlConstants.DEFAULT.equals(annotation.name()))
         groupName = new QName(groupNs, annotation.name());


      ModelGroupBinding group = null;
      boolean createGroup = true;
      if (groupName != null)
      {
         group = schemaBinding.getGroup(groupName);
         if(group != null)
            createGroup = false;
      }


      TypeInfo groupType = property.getType();
      if(groupType.isCollection())
         groupType = ((ClassInfo)groupType).getComponentType();


      if(createGroup)
      {
         boolean propOrderMissing = annotation.propOrder().length == 1 && annotation.propOrder()[0].equals("") || annotation.particles().length > 0;
         group = createModelGroup(annotation.kind(), groupType, propOrderMissing, annotation.propOrder());
         if (groupName != null)
         {
            group.setQName(groupName);
            schemaBinding.addGroup(group.getQName(), group);
         }
      }
      
      parentGroup.addParticle(new ParticleBinding(group, 0, 1, property.getType().isCollection()));


      if(annotation.particles().length == 0)
      {
         if(createGroup)
         {
            group.setSkip(Boolean.FALSE);


            // handler for the model group members
            BeanInfo groupBeanInfo = JBossXBBuilder.configuration.getBeanInfo(groupType);
            BeanAdapterFactory propBeanAdapterFactory = createAdapterFactory(DefaultBeanAdapterBuilder.class, groupBeanInfo, null);
            BeanHandler propHandler = new GroupBeanHandler(groupBeanInfo.getName(), propBeanAdapterFactory);
            group.setHandler(propHandler);


            String[] memberOrder = annotation.propOrder();
            if (memberOrder.length == 0 || memberOrder[0].length() == 0)
            {
               List<String> propNames = new ArrayList<String>();
               for (PropertyInfo prop : groupBeanInfo.getProperties())
                  propNames.add(prop.getName());
               memberOrder = propNames.toArray(new String[propNames.size()]);
            }


            if (trace)
               log.trace("Property order for " + annotation.kind() + " property " + property.getName() + ": " + Arrays.asList(memberOrder));


            // bind model group members
            for (String memberPropName : memberOrder)
            {
               if ("class".equals(memberPropName))
                  continue;


               PropertyInfo memberProp = groupBeanInfo.getProperty(memberPropName);
               push(groupType, memberPropName);
               bindProperty(memberProp, group, propBeanAdapterFactory, memberOrder, false);
               pop();
            }
         }
         
         if(group.getQName() == null)
            throw new JBossXBRuntimeException("To be bound a group must have a non-null QName. Bean " + property.getBeanInfo().getName() + ", property=" + property.getName());


         beanAdapterFactory.addProperty(group.getQName(), propertyHandler);
      }
      else
      {
         for (JBossXmlModelGroup.Particle member : annotation.particles())
         {
            XmlElement element = member.element();
            QName memberQName = generateXmlName(element.name(), XmlNsForm.QUALIFIED, element.namespace(), null);


            if(createGroup)
            {
               TypeInfo memberTypeInfo = groupType.getTypeInfoFactory().getTypeInfo(member.type());


               boolean isCol = false;
               if (memberTypeInfo.isCollection())
               {
                  memberTypeInfo = ((ClassInfo) memberTypeInfo).getComponentType();
                  isCol = true;
               }


               TypeBinding memberTypeBinding = resolveTypeBinding(memberTypeInfo);
               ElementBinding memberElement = createElementBinding(memberTypeInfo, memberTypeBinding, memberQName, false);
               memberElement.setNillable(true);
               ParticleBinding memberParticle = new ParticleBinding(memberElement, 0, 1, isCol);
               group.addParticle(memberParticle);
            }
            
            if(propertyHandler != null)
               beanAdapterFactory.addProperty(memberQName, propertyHandler);
            else

View Full Code Here

      defaultNamespace = overridenDefaultNamespace;
   }


   private ModelGroupBinding createModelGroup(String kind, TypeInfo type, boolean propOrderMissing, String[] propertyOrder)
   {
      ModelGroupBinding group;
      if (kind.equals(JBossXmlConstants.MODEL_GROUP_SEQUENCE))
      {
         if(propOrderMissing)
            assertPropOrderNotRequired(type, propertyOrder);
         group = groupFactory.createSequence(schemaBinding);

View Full Code Here

            }
            parameters.add(parameter);
         }
      });


      ModelGroupBinding valueGroup = schemaBinding.getGroup(valueGroupQName);
      for(Iterator<?> i = valueGroup.getParticles().iterator(); i.hasNext();)
      {
         TermBinding term = ((ParticleBinding)i.next()).getTerm();
         if(!term.isWildcard())
         {
            ElementBinding e = (ElementBinding) term;

View Full Code Here

      
      //root
      ElementBinding e = elements.next();
      assertFalse(elements.hasNext());
      assertEquals(new QName("ns.root", "root"), e.getQName());
      ModelGroupBinding group = (ModelGroupBinding) e.getType().getParticle().getTerm();
      Collection<ParticleBinding> particles = group.getParticles();
      assertEquals(2, particles.size());
      Iterator<ParticleBinding> particleIterator = particles.iterator();
      ParticleBinding particle = particleIterator.next();
      
      // child
      e = (ElementBinding) particle.getTerm();
      assertEquals(new QName("ns.child", "child"), e.getQName());
      group = (ModelGroupBinding) e.getType().getParticle().getTerm();
      particles = group.getParticles();
      assertEquals(1, particles.size());
      particle = particles.iterator().next();


      // child/name
      e = (ElementBinding) particle.getTerm();

View Full Code Here

      
      //root
      ElementBinding e = elements.next();
      assertFalse(elements.hasNext());
      assertEquals(new QName("ns.root", "root"), e.getQName());
      ModelGroupBinding group = (ModelGroupBinding) e.getType().getParticle().getTerm();
      Collection<ParticleBinding> particles = group.getParticles();
      assertEquals(2, particles.size());
      Iterator<ParticleBinding> particleIterator = particles.iterator();
      
      ElementBinding child;
      ElementBinding rootName;
      if(group instanceof SequenceBinding)
      {
         child = (ElementBinding) particleIterator.next().getTerm();
         rootName = (ElementBinding) particleIterator.next().getTerm();
      }
      else
      {
         ParticleBinding particle = particleIterator.next();
         ElementBinding el = (ElementBinding) particle.getTerm();
         if(el.getQName().equals(new QName("ns.root", "child")))
         {
            child = el;
            rootName = (ElementBinding) particleIterator.next().getTerm();
         }
         else
         {
            child = (ElementBinding) particleIterator.next().getTerm();
            rootName = el;
         }
      }
      
      // child
      assertEquals(new QName("ns.root", "child"), child.getQName());
      group = (ModelGroupBinding) child.getType().getParticle().getTerm();
      particles = group.getParticles();
      assertEquals(1, particles.size());
      ParticleBinding particle = particles.iterator().next();


      // child/name
      e = (ElementBinding) particle.getTerm();

View Full Code Here

0 1 2 3 4 5 6 7

TOP

Related Classes of org.jboss.xb.binding.sunday.unmarshalling.ModelGroupBinding

org.jboss.metadata.test.generator.SchemaGenerator

org.jboss.test.aop.junit.SchemaPrinter

org.jboss.test.classloading.metadata.xml.SchemaPrinter

org.jboss.test.classloading.vfs.metadata.xml.SchemaPrinter

org.jboss.test.metadata.binding.SchemaBindingValidationTest

org.jboss.test.xb.builder.AbstractBuilderTest

org.jboss.test.xb.builder.object.element.jbossxmlnsprefix.test.JBossXmlNsPrefixUnitTestCase

org.jboss.test.xb.builder.object.type.accessor.test.AlphaUnitTestCase

org.jboss.test.xb.builder.object.type.accessor.test.SequenceUnitTestCase

org.jboss.test.xb.builder.object.type.collection.test.AbstractCollectionTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.