com.sun.xml.internal.xsom.XSParticle Java Examples

public void particle( XSParticle p ) {
    XSTerm t = p.getTerm();

    if(marked(p)) {
        BIProperty cust = BIProperty.getCustomization(p);
        CPropertyInfo prop = cust.createElementOrReferenceProperty(
            getLabel(p), false, p, RawTypeSetBuilder.build(p,insideOptionalParticle));
        getCurrentBean().addProperty(prop);
    } else {
        // repeated model groups should have been marked already
        assert !p.isRepeated();

        boolean oldIOP = insideOptionalParticle;
        insideOptionalParticle |= BigInteger.ZERO.equals(p.getMinOccurs());
        // this is an unmarked particle
        t.visit(this);
        insideOptionalParticle = oldIOP;
    }
}
 

public boolean isApplicable(XSComplexType ct) {
    if( !bgmBuilder.getGlobalBinding().isChoiceContentPropertyEnabled() )
        return false;

    if( ct.getBaseType()!=schemas.getAnyType() )
        // My reading of the spec is that if a complex type is
        // derived from another complex type by extension,
        // its top level model group is always a sequence
        // that combines the base type content model and
        // the extension defined in the new complex type.
        return false;

    XSParticle p = ct.getContentType().asParticle();
    if(p==null)
        return false;

    XSModelGroup mg = getTopLevelModelGroup(p);

    if( mg.getCompositor()!=XSModelGroup.CHOICE )
        return false;

    if( p.isRepeated() )
        return false;

    return true;
}
 

public void particle( XSParticle p ) {
    XSTerm t = p.getTerm();

    if(marked(p)) {
        BIProperty cust = BIProperty.getCustomization(p);
        CPropertyInfo prop = cust.createElementOrReferenceProperty(
            getLabel(p), false, p, RawTypeSetBuilder.build(p,insideOptionalParticle));
        getCurrentBean().addProperty(prop);
    } else {
        // repeated model groups should have been marked already
        assert !p.isRepeated();

        boolean oldIOP = insideOptionalParticle;
        insideOptionalParticle |= BigInteger.ZERO.equals(p.getMinOccurs());
        // this is an unmarked particle
        t.visit(this);
        insideOptionalParticle = oldIOP;
    }
}
 

/**
 * Finds a {@link XSParticle} that can serve as the representative property of
 * the given {@link ConnectedComponent}.
 *
 * The representative property is used for reporting an error location and
 * taking {@link BIProperty} customization. Right now, the algorithm is just pick
 * the first one with {@link BIProperty}, but one can think of a better algorithm,
 * such as taking a choice of (A|B) if CC={A,B}.
 */
private XSParticle findSourceParticle(ConnectedComponent cc) {
    XSParticle first = null;

    for (Element e : cc) {
        GElement ge = (GElement)e;
        for (XSParticle p : ge.particles) {
            if(first==null)
                first = p;
            if(getLocalPropCustomization(p)!=null)
                return p;
        }
        // if there are multiple property customizations,
        // all but one will be left unused, which will be detected as an error
        // later, so no need to check that now.
    }

    // if no customization was found, just use the first one.
    return first;
}
 

/**
 * Finds a {@link XSParticle} that can serve as the representative property of
 * the given {@link ConnectedComponent}.
 *
 * The representative property is used for reporting an error location and
 * taking {@link BIProperty} customization. Right now, the algorithm is just pick
 * the first one with {@link BIProperty}, but one can think of a better algorithm,
 * such as taking a choice of (A|B) if CC={A,B}.
 */
private XSParticle findSourceParticle(ConnectedComponent cc) {
    XSParticle first = null;

    for (Element e : cc) {
        GElement ge = (GElement)e;
        for (XSParticle p : ge.particles) {
            if(first==null)
                first = p;
            if(getLocalPropCustomization(p)!=null)
                return p;
        }
        // if there are multiple property customizations,
        // all but one will be left unused, which will be detected as an error
        // later, so no need to check that now.
    }

    // if no customization was found, just use the first one.
    return first;
}
 

public Multiplicity modelGroup(XSModelGroup group) {
    boolean isChoice = group.getCompositor() == XSModelGroup.CHOICE;

    Multiplicity r = ZERO;

    for( XSParticle p : group.getChildren()) {
        Multiplicity m = particle(p);

        if(r==null) {
            r=m;
            continue;
        }
        if(isChoice) {
            r = Multiplicity.choice(r,m);
        } else {
            r = Multiplicity.group(r,m);
        }
    }
    return r;
}
 

private CCustomizations getCustomizations( XSParticle src ) {
    // customizations for a particle  should include those defined in the term unless it's global
    // this is so that the schema like:
    //
    // <xs:sequence>
    //   <xs:element name="foo" type="xs:int">
    //     <xs:annotation><xs:appinfo>
    //       <hyperjaxb:... />
    //
    // would be picked up
    if(src.getTerm().isElementDecl()) {
        XSElementDecl xed = src.getTerm().asElementDecl();
        if(xed.isGlobal())
            return getCustomizations((XSComponent)src);
    }

    return getCustomizations(src,src.getTerm());
}
 

public boolean isApplicable(XSComplexType ct) {
    if (!bgmBuilder.model.options.contentForWildcard) {
        return false;
    }
    XSType bt = ct.getBaseType();
    if (bt ==schemas.getAnyType() && ct.getContentType() != null) {
        XSParticle part = ct.getContentType().asParticle();
        if ((part != null) && (part.getTerm().isModelGroup())) {
            XSParticle[] parts = part.getTerm().asModelGroup().getChildren();
            int wildcardCount = 0;
            int i = 0;
            while ((i < parts.length) && (wildcardCount <= 1)) {
                if (parts[i].getTerm().isWildcard()) {
                    wildcardCount += 1;
                }
                i++;
            }
            return (wildcardCount > 1);
        }
    }
    return false;
}
 

private CCustomizations getCustomizations( XSParticle src ) {
    // customizations for a particle  should include those defined in the term unless it's global
    // this is so that the schema like:
    //
    // <xs:sequence>
    //   <xs:element name="foo" type="xs:int">
    //     <xs:annotation><xs:appinfo>
    //       <hyperjaxb:... />
    //
    // would be picked up
    if(src.getTerm().isElementDecl()) {
        XSElementDecl xed = src.getTerm().asElementDecl();
        if(xed.isGlobal())
            return getCustomizations((XSComponent)src);
    }

    return getCustomizations(src,src.getTerm());
}
 

private boolean containingChoice(CClassInfo typeBean) {
    XSComponent component = typeBean.getSchemaComponent();
    if (component instanceof XSComplexType) {
        XSContentType contentType = ((XSComplexType) component).getContentType();
        XSParticle particle = contentType.asParticle();
        if (particle != null) {
            XSTerm term = particle.getTerm();
            XSModelGroup modelGroup = term.asModelGroup();
            if (modelGroup != null) {
                return (modelGroup.getCompositor() == XSModelGroup.Compositor.CHOICE);
            }
        }
    }

    return false;
}
 

@Override
public void build( XSParticle p, Collection<XSParticle> forcedProps ) {
    Checker checker = checkCollision(p,forcedProps);

    if(checker.hasNameCollision()) {
        CReferencePropertyInfo prop = new CReferencePropertyInfo(
            getCurrentBean().getBaseClass()==null?"Content":"Rest",
            true, false, false, p,
            builder.getBindInfo(p).toCustomizationList(),
            p.getLocator(), false, false, false);
        RawTypeSetBuilder.build(p,false).addTo(prop);
        prop.javadoc = Messages.format( Messages.MSG_FALLBACK_JAVADOC,
                checker.getCollisionInfo().toString() );

        getCurrentBean().addProperty(prop);
    } else {
        new Builder(checker.markedParticles).particle(p);
    }
}
 

/**
 * Gets the {@link BIDom} object that applies to the given particle.
 */
protected final BIDom getLocalDomCustomization( XSParticle p ) {
    if (p == null) {
        return null;
    }
    BIDom dom = getBindInfo(p).get(BIDom.class);
    if(dom!=null)  return dom;

    // if not, the term might have one.
    dom = getBindInfo(p.getTerm()).get(BIDom.class);
    if(dom!=null)  return dom;

    XSTerm t = p.getTerm();
    // type could also have one, in case of the dom customization
    if(t.isElementDecl())
        return getBindInfo(t.asElementDecl().getType()).get(BIDom.class);
    // similarly the model group in a model group definition may have one.
    if(t.isModelGroupDecl())
        return getBindInfo(t.asModelGroupDecl().getModelGroup()).get(BIDom.class);

    return null;
}
 

public boolean isApplicable(XSComplexType ct) {
    if (!bgmBuilder.model.options.contentForWildcard) {
        return false;
    }
    XSType bt = ct.getBaseType();
    if (bt ==schemas.getAnyType() && ct.getContentType() != null) {
        XSParticle part = ct.getContentType().asParticle();
        if ((part != null) && (part.getTerm().isModelGroup())) {
            XSParticle[] parts = part.getTerm().asModelGroup().getChildren();
            int wildcardCount = 0;
            int i = 0;
            while ((i < parts.length) && (wildcardCount <= 1)) {
                if (parts[i].getTerm().isWildcard()) {
                    wildcardCount += 1;
                }
                i++;
            }
            return (wildcardCount > 1);
        }
    }
    return false;
}
 

@Override
public void build( XSParticle p, Collection<XSParticle> forcedProps ) {
    Checker checker = checkCollision(p,forcedProps);

    if(checker.hasNameCollision()) {
        CReferencePropertyInfo prop = new CReferencePropertyInfo(
            getCurrentBean().getBaseClass()==null?"Content":"Rest",
            true, false, false, p,
            builder.getBindInfo(p).toCustomizationList(),
            p.getLocator(), false, false, false);
        RawTypeSetBuilder.build(p,false).addTo(prop);
        prop.javadoc = Messages.format( Messages.MSG_FALLBACK_JAVADOC,
                checker.getCollisionInfo().toString() );

        getCurrentBean().addProperty(prop);
    } else {
        new Builder(checker.markedParticles).particle(p);
    }
}
 

public void modelGroup( XSModelGroup mg ) {
    boolean oldIOP = insideOptionalParticle;
    insideOptionalParticle |= mg.getCompositor()==XSModelGroup.CHOICE;

    for( XSParticle p : mg.getChildren())
        particle(p);

    insideOptionalParticle = oldIOP;
}
 

/**
 * Hides the computeLabel method of the outer class
 * and adds caching.
 */
private String computeLabel( XSParticle p ) {
    String label = labelCache.get(p);
    if(label==null)
        labelCache.put( p, label=DefaultParticleBinder.this.computeLabel(p) );
    return label;
}
 

private void visit(XSModelGroup mg, List<XSComponent> r) {
    // since model groups never form a cycle, no cycle check is needed
    r.add(mg);
    for (XSParticle p : mg) {
        XSModelGroup child = p.getTerm().asModelGroup();
        if(child!=null)
            visit(child,r);
    }
}
 

public Iterator<T> modelGroup(XSModelGroup group) {
    // compensate for particles that are ignored in SCD
    return new Iterators.Map<T,XSParticle>(group.iterator()) {
        protected Iterator<? extends T> apply(XSParticle p) {
            return particle(p);
        }
    };
}
 

public void modelGroup(XSModelGroup group) {
    if(!visited.add(group))  return;

    for (XSParticle p : group.getChildren()) {
        particle(p);
    }
}
 

/**
 * Gets a {@link NameClass} that represents all the terms in the given content type.
 * If t is not a particle, just return an empty name class.
 */
private NameClass getNameClass(XSContentType t) {
    if(t==null) return NameClass.NULL;
    XSParticle p = t.asParticle();
    if(p==null) return NameClass.NULL;
    else        return p.getTerm().apply(contentModelNameClassBuilder);
}
 

public void build(XSParticle p, Collection<XSParticle> forcedProps) {
    // this class isn't about spec conformance, but
    // for the ease of use.
    // so we don't give a damn about 'forcedProps'.
    // although, for a future note, it's conceivable to expand
    // the binding algorithm to cover this notion.

    Expression tree = ExpressionBuilder.createTree(p);
    Graph g = new Graph(tree);
    for (ConnectedComponent cc : g) {
        buildProperty(cc);
    }
}
 

public Iterator<T> complexType(XSComplexType type) {
    // compensate particle
    XSParticle p = type.getContentType().asParticle();
    if(p!=null)
        return particle(p);
    else
        return empty();
}
 

/**
 *
 *
 * @param defaultName
 *      If the name is not customized, this name will be used
 *      as the default. Note that the name conversion <b>MUST</b>
 *      be applied before this method is called if necessary.
 * @param source
 *      Source schema component from which a field is built.
 */
public CElementPropertyInfo createElementProperty(String defaultName, boolean forConstant, XSParticle source,
                                                  RawTypeSet types) {

    if(!types.refs.isEmpty())
        // if this property is empty, don't acknowleedge the customization
        // this allows pointless property customization to be reported as an error
        markAsAcknowledged();
    constantPropertyErrorCheck();

    String name = getPropertyName(forConstant);
    if(name==null)
        name = defaultName;

    CElementPropertyInfo prop = wrapUp(
        new CElementPropertyInfo(
            name, types.getCollectionMode(),
            types.id(),
            types.getExpectedMimeType(),
            source, getCustomizations(source),
            source.getLocator(), types.isRequired()),
        source);

    types.addTo(prop);

    BIInlineBinaryData.handle(source.getTerm(), prop);
    return prop;
}
 

protected final <T extends BIDeclaration> T getLocalCustomization( XSParticle p, Class<T> type ) {
    // check the property customization of this component first
    T cust = builder.getBindInfo(p).get(type);
    if(cust!=null)  return cust;

    // if not, the term might have one.
    cust = builder.getBindInfo(p.getTerm()).get(type);
    if(cust!=null)  return cust;

    return null;
}
 

private Checker checkCollision( XSParticle p, Collection<XSParticle> forcedProps ) {
    // scan the tree by a checker.
    Checker checker = new Checker(forcedProps);

    CClassInfo superClass = getCurrentBean().getBaseClass();

    if(superClass!=null)
        checker.readSuperClass(superClass);
    checker.particle(p);

    return checker;
}
 

public Multiplicity particle( XSParticle p ) {
    Multiplicity m = p.getTerm().apply(this);

    BigInteger max;
    if (m.max==null || (BigInteger.valueOf(XSParticle.UNBOUNDED).equals(p.getMaxOccurs())))
        max=null;
    else
        max=p.getMaxOccurs();

    return Multiplicity.multiply( m, Multiplicity.create(p.getMinOccurs(),max) );
}
 

public void modelGroup( XSModelGroup mg ) {
    boolean oldIOP = insideOptionalParticle;
    insideOptionalParticle |= mg.getCompositor()==XSModelGroup.CHOICE;

    for( XSParticle p : mg.getChildren())
        particle(p);

    insideOptionalParticle = oldIOP;
}
 

protected final <T extends BIDeclaration> T getLocalCustomization( XSParticle p, Class<T> type ) {
    // check the property customization of this component first
    T cust = builder.getBindInfo(p).get(type);
    if(cust!=null)  return cust;

    // if not, the term might have one.
    cust = builder.getBindInfo(p.getTerm()).get(type);
    if(cust!=null)  return cust;

    return null;
}
 

public Iterator<T> modelGroup(XSModelGroup group) {
    // compensate for particles that are ignored in SCD
    return new Iterators.Map<T,XSParticle>(group.iterator()) {
        protected Iterator<? extends T> apply(XSParticle p) {
            return particle(p);
        }
    };
}
 

private Checker checkCollision( XSParticle p, Collection<XSParticle> forcedProps ) {
    // scan the tree by a checker.
    Checker checker = new Checker(forcedProps);

    CClassInfo superClass = getCurrentBean().getBaseClass();

    if(superClass!=null)
        checker.readSuperClass(superClass);
    checker.particle(p);

    return checker;
}