Project

Clover coverage report - JBind Project
Coverage timestamp: Fr Mai 28 2004 11:17:36 CEST
file stats:	LOC:	558		Methods:	24
	NCLOC:	412		Classes:	1
This license of Clover is provided to support the development of JBind only. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover.
Source file
Conditionals
Statements
Methods
TOTAL
ComplexTypeDef.java
80,3%
88,9%
83,3%
85,6%
 /*
  * JBind
  *
  * Copyright (c) by Stefan Wachter. All rights reserved.
  *
  * Usage, modification, and redistribution is subject to license terms that are
  * available at 'http://www.jbind.org'. The JBind license is like the
  * 'Apache Software License V 1.1'.
  */
 package org.jbind.xml.schema.element;
 
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.Set;
 
 import org.jbind.xml.base.FinalType;
 import org.jbind.xml.base.IAttribute;
 import org.jbind.xml.base.IBindingAttributes;
 import org.jbind.xml.base.IRef;
 import org.jbind.xml.base.Range;
 import org.jbind.xml.core.cmp.IAttributesModel;
 import org.jbind.xml.core.cmp.IComplexContentModel;
 import org.jbind.xml.core.cmp.IComponent;
 import org.jbind.xml.core.cmp.IComponentStore;
 import org.jbind.xml.core.cmp.IContentModel;
 import org.jbind.xml.core.cmp.ISchema;
 import org.jbind.xml.core.constraint.IConstraint;
 import org.jbind.xml.core.constraint.IConstraints;
 import org.jbind.xml.core.constraint.IIdentityConstraint;
 import org.jbind.xml.core.constraint.IIdentityConstraintComponent;
 import org.jbind.xml.core.content.IAttrGroupDecl;
 import org.jbind.xml.core.content.IAttrRefOrDecl;
 import org.jbind.xml.core.content.IElemGroupDesc;
 import org.jbind.xml.core.type.IAnyType;
 import org.jbind.xml.core.type.IListType;
 import org.jbind.xml.msg.IConstraintViolations;
 import org.jbind.xml.msg.XmlException;
 import org.jbind.xml.msg.XmlMessages;
 import org.jbind.xml.schema.cmp.ComplexContentModel;
 import org.jbind.xml.schema.cmp.ComplexType;
 import org.jbind.xml.schema.cmp.ComplexTypeCC;
 import org.jbind.xml.schema.cmp.ComplexTypeSC;
 import org.jbind.xml.schema.cmp.SequenceDecl;
 import org.jbind.xml.schema.cmp.W3CTypes;
 import org.jbind.xml.schema.cmp.XPathMethod;
 import org.jbind.xml.schema.constraint.AttributesConstraint;
 import org.jbind.xml.schema.constraint.Constraints;
 import org.jbind.xml.schema.constraint.IdConstraint;
 import org.jbind.xml.schema.constraint.IdRefConstraint;
 import org.jbind.xml.schema.constraint.IdRefsConstraint;
 import org.jbind.xml.schema.constraint.IdsConstraint;
 import org.jbind.xml.schema.instantiation.IComponentSetter;
 import org.jbind.xml.schema.instantiation.IElemValHelper;
 import org.jbind.xml.schema.instantiation.IElementHelper;
 import org.jbind.xml.schema.instantiation.IJobRefs;
 import org.jbind.xml.schema.instantiation.ITopLevelElement;
 
 public class ComplexTypeDef extends TypeDef implements IComplexTypeDef {
 
   private CreationParams myCreationParams = null;
 
   private boolean myIsAbstract = false;
   private Boolean myIsMixed = null;
 
   private Set myBlockTypes = Collections.EMPTY_SET;
 
   /**
    * <i>(required)</i>.
    * The complexContent or simpleContent element. If there is no nested content model
    * element then the abbreviated content model is used.
    */
   private IContentModelDesc myContentModelDesc = null;
 
   /**
    * Inlined model group definition. The model group definition may either be a direct
    * decendant of the complex type or enclosed by a complex content element.
    */
   private IModelGroup myInlinedModelGroup = null;
 
   /**
    * Referenced model group definition. The reference may either be a direct decendant
    * of the complex type or enclosed by a complex content element.
    */
   private IModelGroupRef myModelGroupRef = null;
 
   /**
    *
    */
   private IAttributeInfos myAttributeInfos = null;
 
   /**
    * Constraints whose creation is started in the creation step.
    */
   private final IConstraints myComponentConstraints = new Constraints();
 
   private IElemGroupDesc myLocalGroup = null;
 
   private boolean myIsExtension = false;
 
   public ComplexTypeDef(CreationParams aCreationParams, String aRole) {
     super(aCreationParams, aRole);
     myCreationParams = aCreationParams;
   }
 
   protected IAttribute doCreateAttribute(ACParams anACParams) throws XmlException {
     IAttribute res = null;
     String an = NameUtil.getSchemaAttributeName(anACParams);
     if ("abstract".equals(an)) {
       res = new BooleanAttribute(anACParams);
       myIsAbstract = res.getBoolean();
     } else if ("mixed".equals(an)) {
       res = new BooleanAttribute(anACParams);
       setIsMixed(new Boolean(res.getBoolean()));
     } else if ("block".equals(an)) {
       res = new Attribute(anACParams);
       myBlockTypes = ConstantResolver.getBlockTypes(res.getStringValue(), this);
     } else {
       res = super.doCreateAttribute(anACParams);
     }
     return res;
   }
 
   protected IElement doCreateChild(CreationParams aCreationParams) throws XmlException {
     IElement res = null;
     String componentName = NameUtil.getSchemaComponentName(aCreationParams);
     if ("simpleContent".equals(componentName)) {
       res = new SimpleContentModelDesc(aCreationParams, getRole());
     } else if ("complexContent".equals(componentName)) {
       res = new ComplexContentModelDesc(aCreationParams);
     } else if ("group".equals(componentName)) {
       res = new ModelGroupRef(aCreationParams);
     } else if ("all".equals(componentName)) {
       res = new AllModelGroup(aCreationParams);
     } else if ("choice".equals(componentName)) {
       res = new ChoiceModelGroup(aCreationParams);
     } else if ("sequence".equals(componentName)) {
       res = new SequenceModelGroup(aCreationParams);
     } else if ("attribute".equals(componentName)) {
       res = new AttributeDeclaration(aCreationParams, true);
     } else if ("attributeGroup".equals(componentName)) {
       res = new AttributeGroupRef(aCreationParams);
     } else if ("anyAttribute".equals(componentName)) {
       res = new AnyAttribute(aCreationParams);
     } else {
       res = super.doCreateChild(aCreationParams);
     }
     return res;
   }
 
 
   public Set getBlockTypes() {
     return myBlockTypes;
   }
 
   public boolean getIsAbstract() {
     return myIsAbstract;
   }
 
 
   public Boolean isMixed() {
     return myIsMixed;
   }
   public void setIsMixed(Boolean aBoolean) {
     myIsMixed = aBoolean;
   }
 
 
   public IAttributeInfos getAttributeInfos() {
     return myAttributeInfos;
   }
 
   public void validateElement(IElemValHelper aHelper, IConstraintViolations aViolations) {
     super.validateElement(aHelper, aViolations);
 
     myContentModelDesc = (IContentModelDesc)getSubElement(IContentModelDesc.class, "duplicate content model", aViolations);
     myInlinedModelGroup = (IModelGroup)getSubElement(IModelGroup.class, "duplicate model group", aViolations);
     myModelGroupRef = (IModelGroupRef)getSubElement(IModelGroupRef.class, "duplicate model group reference", aViolations);
 
     // Only one of ContentModel, InlinedModelGroup, or ModelGroupRef must exist
     if (((null != myContentModelDesc) && (null != myInlinedModelGroup)) || ((null != myContentModelDesc) && (null != myModelGroupRef)) || ((null != myInlinedModelGroup) && (null != myModelGroupRef))) {
       aViolations.add(XmlMessages.invalidContentModel(this));
     }
 
     if (null == myContentModelDesc) {
       // There is no simpleContent or complexContent element
 
       myAttributeInfos = new AttributeInfos(this);
       myContentModelDesc = new AbbreviatedContentModel(myCreationParams, myInlinedModelGroup, myModelGroupRef);
 
     } else {
       // There is a simpleContent or complexContent element
 
       if (iterChildrenByClass(IAttributeDeclaration.class).hasNext() || iterChildrenByClass(IAttributeGroupRef.class).hasNext() || iterChildrenByClass(IAnyAttribute.class).hasNext()) {
         aViolations.add(XmlMessages.unexpectedAttributeInfo(this));
       }
 
       myAttributeInfos = myContentModelDesc.getDerivation().getAttributeInfos();
       myInlinedModelGroup = myContentModelDesc.getDerivation().getModelGroup();
       myModelGroupRef = myContentModelDesc.getDerivation().getModelGroupRef();
 
     }
 
     if (!myContentModelDesc.isComplex() && (null != isMixed())) {
       aViolations.add(XmlMessages.mixedOnlyAllowedForCc(this));
     }
 
     myAttributeInfos.validate(aViolations);
 
     myIsExtension = myContentModelDesc.getDerivation().getIsExtension();
 
   }
 
 
   //
   // Implementation of IComponentJobHelper
   //
 
   public void collectRefsForCreation(IJobRefs aJobRefs) {
     if (myContentModelDesc.isComplex()) {
       // The base type of a complex type with a complex content model needs not
       // to be validated for the complex type to be created.
       // The reason is that the base type may depend on this type and may be validated
       // only after this type was created.
       aJobRefs.add(myContentModelDesc.getDerivation().getBaseAttribute(), false, myContentModelDesc.getDerivation());
     } else {
       // The base type of a complex type with a simple content model must have been validated.
       // The content type of the base type is accessed in the creation step of this
       // complex type.
       if (null != myContentModelDesc.getDerivation().getBaseAttribute()) {
         aJobRefs.add(myContentModelDesc.getDerivation().getBaseAttribute(), true, myContentModelDesc.getDerivation());
       }
       if (null != myContentModelDesc.getDerivation().getInlinedBaseAttribute()) {
         // The content model may contain an inlined type whose base must have been validated.
         aJobRefs.add(myContentModelDesc.getDerivation().getInlinedBaseAttribute(), true, myContentModelDesc.getDerivation());
       }
     }
     myAttributeInfos.collectRefsForCreation(aJobRefs);
   }
 
 
   public void collectRefsForCompletion(IElementHelper anElementHelper, IJobRefs aJobRefs) {
     if (myContentModelDesc.isComplex()) {
       aJobRefs.add(myContentModelDesc.getDerivation().getBaseAttribute(), true, myContentModelDesc.getDerivation());
     }
     if (null != myModelGroupRef) {
       aJobRefs.add(myModelGroupRef.getRef(), true, myModelGroupRef);
     }
   }
 
   public void collectRefsForValidation(IElementHelper anElementHelper, IJobRefs aJobRefs) {}
 
 
   public IComponent createComponent(IElementHelper anElementHelper, final IConstraintViolations aViolations) {
     Set finalTypes = getFinalTypes();
     if (null == finalTypes) {
       finalTypes = getSchemaElement().getDefaultFinalTypes();
     }
     Set blockTypes = getBlockTypes();
     if (null == blockTypes) {
       blockTypes = getSchemaElement().getDefaultBlockTypes();
     }
 
     ComplexType res = null;
 
     if (myContentModelDesc.isComplex()) {
       res = new ComplexTypeCC(this, getTargetNamespace(), getName(), getRole(), finalTypes, blockTypes, myIsAbstract, myIsExtension);
     } else {
       res = new ComplexTypeSC(this, getTargetNamespace(), getName(), getRole(), finalTypes, blockTypes, myIsAbstract, myIsExtension);
     }
 
     IAnyType bType = null;
     if (null != myContentModelDesc.getDerivation().getBaseAttribute()) {
       bType = (IAnyType)anElementHelper.getComponent(myContentModelDesc.getDerivation().getBaseAttribute(), false);
     }
     IAnyType baseType = (IAnyType)anElementHelper.getComponent(myContentModelDesc.getDerivation().getEffectiveBaseAttribute(), false);
 
     if ((null != bType) && !bType.isBaseType(baseType)) {
       aViolations.add(XmlMessages.inlinedTypeNotSubType(this));
     }
 
     if (myIsExtension && baseType.isActive(FinalType.EXTENSION)) {
       aViolations.add(XmlMessages.baseTypeMustNotBeExtended(this));
     }
     if (!myIsExtension && baseType.isActive(FinalType.RESTRICTION)) {
       aViolations.add(XmlMessages.baseTypeMustNotBeRestricted(this));
     }
 
     res.setBaseType(baseType);
 
     IAttributesModel baseModel = baseType.getAttributesModel();
     final IAttributesModel attributesModel = myIsExtension ? baseModel.extend(res) : baseModel.restrict(res);
     res.setAttributesModel(attributesModel);
 
     AttributesModelGroupCreator creator = new AttributesModelGroupCreator(myAttributeInfos);
 
     anElementHelper.addSubJob(creator, new IComponentSetter() {
       public void set(IComponent aComponent, IConstraintViolations aVls) {
         attributesModel.setAttrGroupDecl((IAttrGroupDecl)aComponent);
       }
     });
 
     if (myContentModelDesc.isComplex()) {
       // A complex type with complex or mixed content
       //
       // - Create the (complex) content model (the group use is not set because
       //   an inlined model group must first be created by a sub job.
       // - Start a sub job for the element group (if necessary)
 
       // The base type must have a complex content model
       IContentModel baseContentModel = baseType.getContentModel();
       if (!baseContentModel.isComplex()) {
         aViolations.add(XmlMessages.baseContentModelMustBeComplex(this));
       }
 
       IComplexContentModel complexContentModel = new ComplexContentModel();
       complexContentModel.setIsMixed(getEffectiveMixed());
       res.setContentModel(complexContentModel);
 
       if (null != myInlinedModelGroup) {
         anElementHelper.addSubJob(myInlinedModelGroup, new IComponentSetter() {
           public void set(IComponent aComponent, IConstraintViolations aVls) {
             myLocalGroup = (IElemGroupDesc)aComponent;
           }
         });
       } else if (null != myModelGroupRef) {
         anElementHelper.addSubJob(myModelGroupRef, new IComponentSetter() {
           public void set(IComponent aComponent, IConstraintViolations aVls) {
             myLocalGroup = (IElemGroupDesc)aComponent;
           }
         });
       }
 
     } else {
       // A complex type with simple content
 
       if (myIsExtension && !baseType.isSimple()) {
         aViolations.add(XmlMessages.baseMustBeSimpleOrCTSC(this));
       } else if (!myIsExtension && (!baseType.isComplex() || !baseType.isSimple())) {
         aViolations.add(XmlMessages.baseMustBeCTSC(this));
       }
 
     }
 
     final ISchema schema = getSchema();
 
     for (Iterator a = iterAppInfos(); a.hasNext(); ) {
       IAppInfoElement appInfo = (IAppInfoElement)a.next();
       for (Iterator i = appInfo.iterChildrenByClass(IIdentityConstraintElement.class);
               i.hasNext(); ) {
         IIdentityConstraintElement ice = (IIdentityConstraintElement)i.next();
         anElementHelper.addSubJob(ice, new IComponentSetter() {
           public void set(IComponent aComponent, IConstraintViolations aVls) {
             myComponentConstraints.add((IIdentityConstraintComponent)aComponent, aVls, ComplexTypeDef.this);
             schema.setComponent(aComponent, aVls);
           }
         });
       }
       for (Iterator i = appInfo.iterChildrenByClass(IXPathConstraintElement.class);
               i.hasNext(); ) {
         IXPathConstraintElement ce = (IXPathConstraintElement)i.next();
         try {
           IConstraint c = ce.createXPathConstraint(anElementHelper);
           myComponentConstraints.add(c, aViolations, this);
         } catch (XmlException e) {
           aViolations.add(e.getXmlMessage());
         }
       }
     }
 
     return res;
   }
 
   private boolean getEffectiveMixed() {
     Boolean m = myContentModelDesc.isMixed();
     if (null == m) {
       m = isMixed();
     }
     return (null != m) ? m.booleanValue() : false;
   }
 
   public void completeComponent(IElementHelper anElementHelper, final IComponent aComponent, IConstraintViolations aViolations) {
     ComplexType complexType = (ComplexType)aComponent;
     IAnyType baseType = complexType.getBaseType();
 
     if (myContentModelDesc.isComplex()) {
       // Finish the complex content model.
       // The local group is available now.
 
       IComplexContentModel complexContentModel = (IComplexContentModel)complexType.getContentModel();
 
       IComplexContentModel baseModel = (IComplexContentModel)baseType.getContentModel();
       IElemGroupDesc baseGroup = baseModel.getGroup();
 
       IElemGroupDesc derivedGroup = null;
 
       if (myIsExtension) {
         if (!baseModel.isEmpty() && (baseModel.isMixed() != complexContentModel.isMixed())) {
           aViolations.add(XmlMessages.extensionCanNotChangeMixed(String.valueOf(baseModel.isMixed()), this));
         }
 
         if ((null != myLocalGroup) && (null != baseGroup)) {
           // Use the local group as the source info. Otherwise the created
           // sequence might count as being a top level sequence (if this complex
           // type is a top level component).
           derivedGroup = new SequenceDecl(myLocalGroup, null, null, Range.ONE);
           derivedGroup.add(baseGroup);
           derivedGroup.add(myLocalGroup);
         } else if (null != myLocalGroup) {
           derivedGroup = myLocalGroup;
         } else {
           derivedGroup = baseGroup;
         }
 
       } else {
         derivedGroup = myLocalGroup;
 
       }
 
       complexContentModel.setGroup(derivedGroup);
 
     }
 
 
     IAttributesModel attributesModel = complexType.getAttributesModel();
     attributesModel.completeDerivedModel(aViolations);
 
   }
 
   public void addSchemaData(IComponentStore aComponentStore, IComponent aComponent, IConstraintViolations aViolations) {
     ComplexType type = (ComplexType)aComponent;
     if (!type.isExtension()) {
       IContentModel baseModel = type.getBaseType().getContentModel();
       if (baseModel.isComplex()) {
         IElemGroupDesc baseGroup = ((IComplexContentModel)baseModel).getGroup();
         IComplexContentModel restrictedModel = (IComplexContentModel)type.getContentModel();
         IElemGroupDesc restrictedGroup = restrictedModel.getGroup();
         ComplexTypeDefHelper.validateRestriction(baseGroup, restrictedGroup, aViolations, this);
       }
     }
 
     buildConstraints(aComponentStore, type, aViolations);
     if (!myContentModelDesc.isComplex() && !myIsExtension) {
       // It is a simple content restriction -> collect the facets
       ((ISimpleRestrictionDerivation)myContentModelDesc.getDerivation()).addSchemaData(aComponentStore, aComponent, aViolations);
     }
     type.addXPathMethods(type.getBaseType().getXPathMethods());
     for (Iterator a = iterAppInfos(); a.hasNext(); ) {
       IAppInfoElement appInfo = (IAppInfoElement)a.next();
       for (Iterator i = appInfo.iterChildrenByClass(XPathMethodElement.class);
               i.hasNext(); ) {
         XPathMethodElement me = (XPathMethodElement)i.next();
         IAttribute upa = me.getLocalBindingAttribute(IBindingAttributes.REFERENCED_TYPE);
         IAnyType referencedType = null;
         if (null != upa) {
           referencedType = (IAnyType)aComponentStore.getComponent(upa.getRef());
         }
         XPathMethod xPathMethod = new XPathMethod(me, me.getName(), me.getXPath(), me.getMethodType(), referencedType);
         if (null != type.addXPathMethod(xPathMethod)) {
           aViolations.add(XmlMessages.duplicateXPathMethod(me.getName(), me));
         }
       }
     }
   }
 
   private void buildConstraints(IComponentStore aComponentStore, IAnyType aType, IConstraintViolations aViolations) {
     IAnyType baseType = aType.getBaseType();
 
     IConstraints constraints = baseType.getConstraints().shallowCopy();
     aType.setConstraints(constraints);
     constraints.add(new AttributesConstraint(aType.getAttributesModel()), aViolations, this);
 
     // Add attribute constraints (id, idref, and idrefs)
     IAttributesModel attributesModel = aType.getAttributesModel();
     IAttributesModel baseAttributesModel = aType.getBaseType().getAttributesModel();
     for (Iterator i = attributesModel.iterAttributes(); i.hasNext(); ) {
       IAttrRefOrDecl attr = (IAttrRefOrDecl)i.next();
       IAnyType baseAttributeType = null;
       IAttrRefOrDecl baseAttr = baseAttributesModel.getAttrRefOrDecl(attr.getGlobalRef());
       if (null != baseAttr) {
         baseAttributeType = baseAttr.getType();
       }
       IAnyType type = attr.getType();
       if (type.isInstanceType(W3CTypes.id)) {
         if ((null != baseAttributeType) && baseAttributeType.isInstanceType(W3CTypes.id)) {
           continue;
         }
         IdConstraint c = new IdConstraint(attr, this);
         constraints.add(c, aViolations, this);
         IAttribute upa = attr.getLocalBindingAttribute(IBindingAttributes.REFERENCED_TYPE);
         if (null != upa) {
           c.setDataType((IAnyType)aComponentStore.getComponent(upa.getRef()));
         } else {
           c.setDataType(W3CTypes.anyType);
         }
       } else if (type.isInstanceType(W3CTypes.idRef)) {
         if ((null != baseAttributeType) && baseAttributeType.isInstanceType(W3CTypes.idRef)) {
           continue;
         }
         IIdentityConstraint c = new IdRefConstraint(attr, this);
         constraints.add(c, aViolations, this);
         IAttribute upa = attr.getLocalBindingAttribute(IBindingAttributes.REFERENCED_TYPE);
         if (null != upa) {
           c.setDataType((IAnyType)aComponentStore.getComponent(upa.getRef()));
         } else {
           c.setDataType(W3CTypes.anyType);
         }
       } else if (type instanceof IListType) {
         if (((IListType)type).getItemType().isInstanceType(W3CTypes.idRef)) {
           if ((null != baseAttributeType) && (baseAttributeType instanceof IListType) && ((IListType)baseAttributeType).getItemType().isInstanceType(W3CTypes.idRef)) {
             continue;
           }
           IIdentityConstraint c = new IdRefsConstraint(attr, this);
           constraints.add(c, aViolations, this);
           IAttribute upa = attr.getLocalBindingAttribute(IBindingAttributes.REFERENCED_TYPE);
           if (null != upa) {
             c.setDataType((IAnyType)aComponentStore.getComponent(upa.getRef()));
           } else {
             c.setDataType(W3CTypes.anyType);
           }
         } else if (((IListType)type).getItemType().isInstanceType(W3CTypes.id)) {
           if ((null != baseAttributeType) && (baseAttributeType instanceof IListType) && ((IListType)baseAttributeType).getItemType().isInstanceType(W3CTypes.id)) {
             continue;
           }
           IIdentityConstraint c = new IdsConstraint(attr, this);
           constraints.add(c, aViolations, this);
           IAttribute upa = attr.getLocalBindingAttribute(IBindingAttributes.REFERENCED_TYPE);
           if (null != upa) {
             c.setDataType((IAnyType)aComponentStore.getComponent(upa.getRef()));
           } else {
             c.setDataType(W3CTypes.anyType);
           }
         }
       }
     }
 
     // Add type identity constraints (key, unique, keyRef)
     constraints.add(myComponentConstraints, aViolations, this);
 
   }
 
   public void redefine(ITopLevelElement aRedefinedElement, IConstraintViolations aViolations) {
     if (getGlobalRef().equals(myContentModelDesc.getDerivation().getBaseAttribute())) {
       myContentModelDesc.getDerivation().setBaseAttribute(aRedefinedElement.getGlobalRef());
     } else {
       aViolations.add(XmlMessages.baseTypeOfRedefinitionMustBeItself(getGlobalRef(), myContentModelDesc.getDerivation().getBaseAttribute(), this));
     }
   }
 
   private IRef myRedefinedRef = null;
   public IRef getRedefinedRef() {
     return myRedefinedRef;
   }
   public void setRedefinedRef(IRef aRef) {
     myRedefinedRef = aRef;
   }
 
 }
 