import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private static void dumpParticle(String path, XSParticle particle)
{
   XSTerm term = particle.getTerm();

   switch (term.getType())
   {
      case XSConstants.ELEMENT_DECLARATION:
         dumpElement(path, (XSElementDeclaration) term);
         break;
      case XSConstants.MODEL_GROUP:
         XSModelGroup model_group = (XSModelGroup) term;
         final XSObjectList particles = model_group.getParticles();

         for (int ipar = 0; ipar < particles.getLength(); ipar++)
         {
            dumpParticle(path, (XSParticle) particles.item(ipar));
         }
         break;
      default:
         System.err.println(path + " - UNKNOWN");
   }

}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
/**
 * Finds all the element and complexType references for the specified root element and populates a map entry with
 * element names referenced by the element.
 * 
 * @param elementDeclaration XSElementDeclaration : the root element
 */
private void findReference(XSElementDeclaration elementDeclaration) {
   String elemName = elementDeclaration.getName();
   String thisContext = elemName;
   XSTypeDefinition typeDefinition = elementDeclaration.getTypeDefinition();
   if (null != typeDefinition) {
      String typeDefName = typeDefinition.getName();
      currentNodeNames.clear();
      currentNodeNames.add(elementDeclaration.getName());
      if (typeDefinition instanceof XSComplexTypeDefinition) {
         addToSchemaMap(elemName, typeDefName);
         if (null != typeDefName) {
            thisContext = typeDefName;
         }
         XSParticle particle = ((XSComplexTypeDefinition) typeDefinition).getParticle();
         findReferenceInParticle(thisContext, particle);
      }
      else {
         addToSchemaMap(elemName, typeDefName);
         if (null != typeDefName) {
            thisContext = typeDefName;
         }
      }
   }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
/**
 * Gets the number of occurrences for a particular node based on the XSParticle reference in the schema.
 * 
 * @param particle the particle reference.
 * @param parentElem the parent element.
 * @return the actual no of calculated occurrences.
 */
public int getOccurances(XSParticle particle,
                        Element parentElem) {
   if (null != particle && null != parentElem) {
      int minOccurs = particle.getMinOccurs();
      int maxOccurs = particle.getMaxOccurs();
      
      String particleName = particle.getTerm().getName();
      
      if (choiceListContains(particleName, parentElem)) {
         int numOfSetValues = this.numberOfSetValues(particleName, parentElem);
         return Math.max(1, numOfSetValues);
      }
      else if (0 == minOccurs) {
         return 0;
      }
      else if (minOccurs >= maxOccurs) {
         return minOccurs;
      }
   }
   return DEFAULT_MAX_OCCURS;
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private void appendCardinality(Path path){
    path = path.getParentPath(XSParticle.class);
    if(path!=null){
        XSParticle particle = (XSParticle)path.getElement();
        if(particle.getMinOccurs()==1 && particle.getMaxOccurs()==1)
            return;
        if(particle.getMinOccurs()==0 && particle.getMaxOccurs()==1)
            buff.append("?");
        else if(particle.getMinOccurs()==0 && particle.getMaxOccursUnbounded())
            buff.append("*");
        else if(particle.getMinOccurs()==1 && particle.getMaxOccursUnbounded())
            buff.append("+");
        else{
            buff.append("[");
            if(particle.getMaxOccursUnbounded())
                buff.append(particle.getMinOccurs()).append("+");
            else if(particle.getMinOccurs()==particle.getMaxOccurs())
                buff.append(particle.getMinOccurs());
            else
                buff.append(particle.getMinOccurs()).append(",").append(particle.getMaxOccurs());
            buff.append("]");
        }
    }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
public XSParticle getParticle() {
    // the wildcard used in anyType (content and attribute)
    // the spec will change strict to skip for anyType
    XSWildcardDecl wildcard = new XSWildcardDecl();
    wildcard.fProcessContents = XSWildcardDecl.PC_LAX;
    // the particle for the content wildcard
    XSParticleDecl particleW = new XSParticleDecl();
    particleW.fMinOccurs = 0;
    particleW.fMaxOccurs = SchemaSymbols.OCCURRENCE_UNBOUNDED;
    particleW.fType = XSParticleDecl.PARTICLE_WILDCARD;
    particleW.fValue = wildcard;
    // the model group of a sequence of the above particle
    XSModelGroupImpl group = new XSModelGroupImpl();
    group.fCompositor = XSModelGroupImpl.MODELGROUP_SEQUENCE;
    group.fParticleCount = 1;
    group.fParticles = new XSParticleDecl[1];
    group.fParticles[0] = particleW;
    // the content of anyType: particle of the above model group
    XSParticleDecl particleG = new XSParticleDecl();
    particleG.fType = XSParticleDecl.PARTICLE_MODELGROUP;
    particleG.fValue = group;

    return particleG;
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
protected void collectChildElements(XSParticle particle, Set<String> elementNames) {
	if (particle==null) {
		log.warn("collectChildElements() particle is null, is this a problem?");	
		return;
	}
	XSTerm term = particle.getTerm();
	if (term==null) {
		throw new IllegalStateException("collectChildElements particle.term is null");
	} 
	if (term instanceof XSModelGroup) {
		XSModelGroup modelGroup = (XSModelGroup)term;
		XSObjectList particles = modelGroup.getParticles();
		for (int i=0;i<particles.getLength();i++) {
			XSParticle childParticle = (XSParticle)particles.item(i);
			collectChildElements(childParticle, elementNames);
		}
		return;
	} 
	if (term instanceof XSElementDeclaration) {
		XSElementDeclaration elementDeclaration=(XSElementDeclaration)term;
		String elementName=elementDeclaration.getName();
		if (DEBUG) log.debug("collectChildElements() ElementDeclaration name ["+elementName+"]");
		elementNames.add(elementName);
	}
	return;
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
protected Set<String> findMultipleOccurringChildElements(XSParticle particle) {
	Set<String> result=new HashSet<String>();
	if (particle==null) {
		log.warn("findMultipleOccurringChildElements() typeDefinition particle is null, is this a problem?");	
		return result;
	}
	XSTerm term = particle.getTerm();
	if (term==null) {
		throw new IllegalStateException("findMultipleOccurringChildElements particle.term is null");
	} 
	if (DEBUG) log.debug("findMultipleOccurringChildElements() term name ["+term.getName()+"] occurring unbounded ["+particle.getMaxOccursUnbounded()+"] max occur ["+particle.getMaxOccurs()+"] term ["+ToStringBuilder.reflectionToString(term)+"]");
	if (particle.getMaxOccursUnbounded()||particle.getMaxOccurs()>1) {
		collectChildElements(particle,result);
		return result;
	} 
	if (term instanceof XSModelGroup) {
		XSModelGroup modelGroup = (XSModelGroup)term;
		XSObjectList particles = modelGroup.getParticles();
			if (DEBUG) log.debug("findMultipleOccurringChildElements() modelGroup particles ["+ToStringBuilder.reflectionToString(particles)+"]");
			for (int i=0;i<particles.getLength();i++) {
				XSParticle childParticle = (XSParticle)particles.item(i);
				result.addAll(findMultipleOccurringChildElements(childParticle));
			}
	} 
	return result;
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
/**
 * Finds all the element and complexType references for the specified element and populates a map entry with element
 * names referenced by the element.
 * 
 * @param context the context.
 * @param elementDeclaration the element declaration.
 */
private void findElementReference(String context,
                                  XSElementDeclaration elementDeclaration) {
   XSTypeDefinition typeDefinition = elementDeclaration.getTypeDefinition();
   if (null != typeDefinition) {
      String typeDefName = typeDefinition.getName();
      if (typeDefinition instanceof XSComplexTypeDefinition) {
         addToSchemaMap(context, typeDefName);
         if (null != typeDefName) {
            context = typeDefName;
         }
         XSParticle particle = ((XSComplexTypeDefinition) typeDefinition).getParticle();
         if (currentNodeNames.contains(typeDefName)) {
            /* circular reference */
            // currentNodeNames.add(typeDefName);
            // findReferenceInParticle(context, particle);
         }
         else {
            currentNodeNames.add(typeDefName);
            findReferenceInParticle(context, particle);
         }
      }
      else {
         addToSchemaMap(context, typeDefName);
         if (null != typeDefName) {
            context = typeDefName;
         }
         currentNodeNames.add(typeDefName);
      }
   }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
/**
 * Finds all the element and complexType references for a particle element and populates a map entry with element
 * names referenced by the element.
 * 
 * @param context the context.
 * @param particle the particle.
 */
private void findReferenceInParticle(String context,
                                     XSParticle particle) {
   if (null != particle) {
      XSTerm term = particle.getTerm();
      if (term instanceof XSModelGroup) {
         XSObjectList xsObjectList = ((XSModelGroup) term).getParticles();
         for (int i = 0; i < xsObjectList.getLength(); i++) {
            XSObject xsObject = xsObjectList.item(i);
            if (xsObject instanceof XSParticle) {
               findReferenceInParticle(context, (XSParticle) xsObject);
            }
         }
      }
      else if (term instanceof XSElementDeclaration) {
         String tName = term.getName();
         addToSchemaMap(context, tName);
         context = tName;
         if (currentNodeNames.contains(tName)) {
            // cyclic reference
            currentNodeNames.add(tName);
            findElementReference(context, (XSElementDeclaration) term);
         }
         else {
            currentNodeNames.add(tName);
            findElementReference(context, (XSElementDeclaration) term);
         }
      }
      // else { // XSWildcard
      // String tName = term.getName();
      // if (tName != null) {
      // addToSchemaTable(aContext, tName);
      // }
      // }
   }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
public String getParticleName(XSParticle particle){
 String itemName = particle.toString();
 if (itemName.contains("{")){
  itemName = itemName.substring(0,itemName.indexOf("{"));
 }
 return itemName;
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private Map<QName,XSParticle> getValidSubTags(XSElementDeclaration elmt) {
    if (!(elmt.getTypeDefinition() instanceof XSComplexTypeDefinition)) {
        return HashMap.empty();
    }
    
    XSComplexTypeDefinition type = (XSComplexTypeDefinition) elmt.getTypeDefinition();
    if (type.getParticle() == null || !(type.getParticle().getTerm() instanceof XSModelGroup)) {
        return HashMap.empty();
    }
    
    XSModelGroup group = (XSModelGroup) type.getParticle().getTerm();
    if (group.getCompositor() != XSModelGroup.COMPOSITOR_SEQUENCE && group.getCompositor() != XSModelGroup.COMPOSITOR_CHOICE) {
        return HashMap.empty();
    }
    
    // We don't care whether it's SEQUENCE or CHOICE, we only want to know what are the valid sub-elements at this level.
    XSObjectList particles = group.getParticles();
    Map<QName,XSParticle> content = HashMap.empty();
    for (int j = 0; j < particles.getLength(); j++) {
        XSParticle sub = (XSParticle) particles.get(j);
        if (sub.getTerm() instanceof XSElementDeclaration) {
            XSElementDeclaration term = (XSElementDeclaration) sub.getTerm();
            content = content.put(new QName(term.getNamespace(), term.getName()), sub);
        }
    }
    return content;
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private Path processParticle(Path parent, String path, XSParticle xsParticle, Map<String, List<XSElementDeclaration>> substitutions,
		List<XSElementDeclaration> parents) throws BagriException {
	
	if (xsParticle == null) {
		return parent;
	}
	
    XSTerm xsTerm = xsParticle.getTerm();
    
    Path particle = parent;
    switch (xsTerm.getType()) {
      case XSConstants.ELEMENT_DECLARATION:

    	  particle = processElement(parent, path, (XSElementDeclaration) xsTerm, substitutions, parents, xsParticle.getMinOccurs(), xsParticle.getMaxOccurs());
    	  break;

      case XSConstants.MODEL_GROUP:

    	  // this is one of the globally defined groups 
    	  // (found in top-level declarations)

    	  XSModelGroup xsGroup = (XSModelGroup) xsTerm;

	      // it also consists of particles
	      XSObjectList xsParticleList = xsGroup.getParticles();
	      for (int i = 0; i < xsParticleList.getLength(); i ++) {
	    	  XSParticle xsp = (XSParticle) xsParticleList.item(i);
	    	  particle = processParticle(parent, path, xsp, substitutions, parents);
	      }

	      //...
	      break;

      case XSConstants.WILDCARD:

          //...
          break;
    }
    return particle;
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private void expandRelatedComplexTypeComponents(XSComplexTypeDecl type, Vector componentList, String namespace, Hashtable dependencies) {
    addRelatedType(type.getBaseType(), componentList, namespace, dependencies);
    expandRelatedAttributeUsesComponents(type.getAttributeUses(), componentList, namespace, dependencies);
    final XSParticle particle = type.getParticle();
    if (particle != null) {
        expandRelatedParticleComponents(particle, componentList, namespace, dependencies);
    }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private void expandRelatedParticleComponents(XSParticle component, Vector componentList,
        String namespace, Hashtable dependencies) {
    XSTerm term = component.getTerm();
    switch (term.getType()) {
    case XSConstants.ELEMENT_DECLARATION :
        addRelatedElement((XSElementDeclaration) term, componentList, namespace, dependencies);
        break;
    case XSConstants.MODEL_GROUP :
        expandRelatedModelGroupComponents((XSModelGroup) term, componentList, namespace, dependencies);
        break;
    default:
        break;
    }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private void expandRelatedModelGroupComponents(XSModelGroup modelGroup, Vector componentList,
        String namespace, Hashtable dependencies) {
    XSObjectList particles = modelGroup.getParticles();
    final int length = (particles == null) ? 0 : particles.getLength();
    for (int i=0; i<length; i++) {
        expandRelatedParticleComponents((XSParticle)particles.item(i), componentList, namespace, dependencies);
    }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
/**
 * Traverse all the deferred local elements. This method should be called
 * by traverseSchemas after we've done with all the global declarations.
 */
void traverseLocalElements() {
    fElementTraverser.fDeferTraversingLocalElements = false;
    
    for (int i = 0; i < fLocalElemStackPos; i++) {
        Element currElem = fLocalElementDecl[i];
        //XSDocumentInfo currSchema = (XSDocumentInfo)fDoc2XSDocumentMap.get(DOMUtil.getDocument(currElem));
        //XSDocumentInfo currSchema = (XSDocumentInfo)fDoc2XSDocumentMap.get(DOMUtil.getRoot(DOMUtil.getDocument(currElem)));
        XSDocumentInfo currSchema = fLocalElementDecl_schema[i];
        SchemaGrammar currGrammar = fGrammarBucket.getGrammar(currSchema.fTargetNamespace);
        fElementTraverser.traverseLocal (fParticle[i], currElem, currSchema, currGrammar, fAllContext[i], fParent[i], fLocalElemNamespaceContext[i]);
        // If it's an empty particle, remove it from the containing component.
        if (fParticle[i].fType == XSParticleDecl.PARTICLE_EMPTY) {
            XSModelGroupImpl group = null;
            if (fParent[i] instanceof XSComplexTypeDecl) {
                XSParticle p = ((XSComplexTypeDecl)fParent[i]).getParticle();
                if (p != null)
                    group = (XSModelGroupImpl)p.getTerm();
            }
            else {
                group = ((XSGroupDecl)fParent[i]).fModelGroup;
            }
            if (group != null)
                removeParticle(group, fParticle[i]);
        }
    }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private void processPSVIParticles(XSObjectList particles) {
    if (particles == null || particles.getLength() == 0) {
        sendElementEvent("psv:particles");
    }
    else {
        sendIndentedElement("psv:particles");
        for (int i = 0; i < particles.getLength(); i++) {
            processPSVIParticle((XSParticle)particles.item(i));
        }
        sendUnIndentedElement("psv:particles");
    }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private void processPSVIParticle(XSParticle part) {
    if (part == null) {
        sendElementEvent("psv:particle");
    }
    else {
        sendIndentedElement("psv:particle");
        sendElementEvent(
            "psv:minOccurs",
            String.valueOf(part.getMinOccurs()));
        sendElementEvent(
            "psv:maxOccurs",
            part.getMaxOccurs() == SchemaSymbols.OCCURRENCE_UNBOUNDED
                ? "unbounded"
                : String.valueOf(part.getMaxOccurs()));
        sendIndentedElement("psv:term");
        switch (part.getTerm().getType()) {
            case XSConstants.ELEMENT_DECLARATION :
                processPSVIElementDeclarationOrRef(
                    (XSElementDeclaration)part.getTerm());
                break;
            case XSConstants.MODEL_GROUP :
                processPSVIModelGroup((XSModelGroup)part.getTerm());
                break;
            case XSConstants.WILDCARD :
                processPSVIWildcard((XSWildcard)part.getTerm());
                break;
        }
        sendUnIndentedElement("psv:term");
        sendUnIndentedElement("psv:particle");
    }
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
/**
 * Is it possible for this element to occur more than once within its
 * enclosing type?
 * @param xiElement
 * @return
 */
private static boolean isElementMultiValued(XSElementDeclaration xiDecl)
{
  boolean lmulti;

  XSComplexTypeDefinition lComplex = xiDecl.getEnclosingCTDefinition();

  if (lComplex == null)
  {
    lmulti = false;
  }
  else
  {
    XSParticle lTopParticle = lComplex.getParticle();

    Boolean lResult = isElementMultiWithin(xiDecl, false, lTopParticle);

    if (lResult == null)
    {
      throw new RuntimeException("Couldn't find declaration of " + xiDecl.getName() + " within " + lComplex.getName());
    }

    lmulti = lResult;
  }

  return lmulti;
}
 

import org.apache.xerces.xs.XSParticle; //导入依赖的package包/类
private TypeDesc processGroup(
    XSModelGroup modelGroup,
    List<XSModel> models,
    Map<String, TypeDesc> jtMap,
    Map<String, NamespaceDesc> nsdMap
) {
    XSModelGroupDefinition def = null;
    for (XSModel xsModel : models) {
        XSNamedMap map = xsModel.getComponents(XSConstants.MODEL_GROUP_DEFINITION);
        for (int i = 0; i < map.getLength(); i++) {
            XSModelGroupDefinition mg = (XSModelGroupDefinition) map.item(i);
            final XSModelGroup xsModelGroup = mg.getModelGroup();
            if (xsModelGroup == modelGroup || xsModelGroup.toString().equals(modelGroup.toString())) {
                def = mg;
                break;
            }
        }
    }
    if (def == null) {
        return null;
    }
    if (!nsdMap.containsKey(def.getNamespace())) {
        Util.log("Namespace desc not found for: " + def);
    }
    String typeName = toJavaTypeName(def, nsdMap);
    final String typeQName = model.toJavaQualifiedTypeName(def, nsdMap, false);
    TypeDesc td = jtMap.get(typeQName);
    if (td != null) {
        if (td.type == TypeDesc.TypeEnum.GROUP_INTERFACE) {
            return td;
        } else {
            Util.logerr("type-group conflict: " + typeName);
            return null;
        }
    } else {
        td = new TypeDesc(def.getName(), def.getNamespace(), typeName, TypeDesc.TypeEnum.GROUP_INTERFACE);
    }

    XSAnnotation ann = def.getAnnotation();
    td.documentation = parseAnnotationString(
        "Type " + def.getNamespace() + ":" + def.getName() + " documentation",
        ann == null ? null : ann.getAnnotationString()
    );
    td.type = TypeDesc.TypeEnum.GROUP_INTERFACE;
    LinkedList<PEntry> plist = new LinkedList<PEntry>();
    for (int i = 0; i < def.getModelGroup().getParticles().getLength(); i++) {
        XSParticle p = (XSParticle) def.getModelGroup().getParticles().item(i);
        plist.add(new PEntry(p, false));
    }
    processParticles(def, plist, nsdMap, jtMap, td, models, null, null);
    jtMap.put(typeQName, td);
    return td;
}