com.sun.tools.internal.xjc.model.nav.NType Java Examples

public JType getTypeClass() {
    CAdapter a = typeUse.getAdapterUse();
    NType nt;
    if(a!=null)
        nt = a.customType;
    else
        nt = typeUse.getInfo().getType();

    JType jt = nt.toType(outline,EXPOSED);

    JPrimitiveType prim = jt.boxify().getPrimitiveType();
    if(!typeUse.isCollection() && prim!=null)
        jt = prim;

    if(typeUse.isCollection())
        jt = jt.array();

    return jt;
}
 

public JType getTypeClass() {
    CAdapter a = typeUse.getAdapterUse();
    NType nt;
    if(a!=null)
        nt = a.customType;
    else
        nt = typeUse.getInfo().getType();

    JType jt = nt.toType(outline,EXPOSED);

    JPrimitiveType prim = jt.boxify().getPrimitiveType();
    if(!typeUse.isCollection() && prim!=null)
        jt = prim;

    if(typeUse.isCollection())
        jt = jt.array();

    return jt;
}
 

public JType getTypeClass() {
    CAdapter a = typeUse.getAdapterUse();
    NType nt;
    if(a!=null)
        nt = a.customType;
    else
        nt = typeUse.getInfo().getType();

    JType jt = nt.toType(outline,EXPOSED);

    JPrimitiveType prim = jt.boxify().getPrimitiveType();
    if(!typeUse.isCollection() && prim!=null)
        jt = prim;

    if(typeUse.isCollection())
        jt = jt.array();

    return jt;
}
 

/**
 * Returns true if {@link #refs} can form refs of types.
 *
 * If there are multiple {@link Ref}s with the same type,
 * we cannot make them into type refs. Or if any of the {@link Ref}
 * says they cannot be in type refs, we cannot do that either.
 *
 * TODO: just checking if the refs are the same is not suffice.
 * If two refs derive from each other, they cannot form a list of refs
 * (because of a possible ambiguity).
 */
private Mode canBeTypeRefs() {
    Set<NType> types = new HashSet<NType>();

    collectionMode = mul.isAtMostOnce()?NOT_REPEATED:REPEATED_ELEMENT;

    // the way we compute this is that we start from the most optimistic value,
    // and then gradually degrade as we find something problematic.
    Mode mode = Mode.SHOULD_BE_TYPEREF;

    for( Ref r : refs ) {
        mode = mode.or(r.canBeType(this));
        if(mode== Mode.MUST_BE_REFERENCE)
            return mode;    // no need to continue the processing

        if(!types.add(r.toTypeRef(null).getTarget().getType()))
            return Mode.MUST_BE_REFERENCE;   // collision
        if(r.isListOfValues()) {
            if(refs.size()>1 || !mul.isAtMostOnce())
                return Mode.MUST_BE_REFERENCE;   // restriction on @XmlList
            collectionMode = REPEATED_VALUE;
        }
    }
    return mode;
}
 

/**
 * Returns true if {@link #refs} can form refs of types.
 *
 * If there are multiple {@link Ref}s with the same type,
 * we cannot make them into type refs. Or if any of the {@link Ref}
 * says they cannot be in type refs, we cannot do that either.
 *
 * TODO: just checking if the refs are the same is not suffice.
 * If two refs derive from each other, they cannot form a list of refs
 * (because of a possible ambiguity).
 */
private Mode canBeTypeRefs() {
    Set<NType> types = new HashSet<NType>();

    collectionMode = mul.isAtMostOnce()?NOT_REPEATED:REPEATED_ELEMENT;

    // the way we compute this is that we start from the most optimistic value,
    // and then gradually degrade as we find something problematic.
    Mode mode = Mode.SHOULD_BE_TYPEREF;

    for( Ref r : refs ) {
        mode = mode.or(r.canBeType(this));
        if(mode== Mode.MUST_BE_REFERENCE)
            return mode;    // no need to continue the processing

        if(!types.add(r.toTypeRef(null).getTarget().getType()))
            return Mode.MUST_BE_REFERENCE;   // collision
        if(r.isListOfValues()) {
            if(refs.size()>1 || !mul.isAtMostOnce())
                return Mode.MUST_BE_REFERENCE;   // restriction on @XmlList
            collectionMode = REPEATED_VALUE;
        }
    }
    return mode;
}
 

/**
 * Returns true if {@link #refs} can form refs of types.
 *
 * If there are multiple {@link Ref}s with the same type,
 * we cannot make them into type refs. Or if any of the {@link Ref}
 * says they cannot be in type refs, we cannot do that either.
 *
 * TODO: just checking if the refs are the same is not suffice.
 * If two refs derive from each other, they cannot form a list of refs
 * (because of a possible ambiguity).
 */
private Mode canBeTypeRefs() {
    Set<NType> types = new HashSet<NType>();

    collectionMode = mul.isAtMostOnce()?NOT_REPEATED:REPEATED_ELEMENT;

    // the way we compute this is that we start from the most optimistic value,
    // and then gradually degrade as we find something problematic.
    Mode mode = Mode.SHOULD_BE_TYPEREF;

    for( Ref r : refs ) {
        mode = mode.or(r.canBeType(this));
        if(mode== Mode.MUST_BE_REFERENCE)
            return mode;    // no need to continue the processing

        if(!types.add(r.toTypeRef(null).getTarget().getType()))
            return Mode.MUST_BE_REFERENCE;   // collision
        if(r.isListOfValues()) {
            if(refs.size()>1 || !mul.isAtMostOnce())
                return Mode.MUST_BE_REFERENCE;   // restriction on @XmlList
            collectionMode = REPEATED_VALUE;
        }
    }
    return mode;
}
 

/**
 * Returns true if {@link #refs} can form refs of types.
 *
 * If there are multiple {@link Ref}s with the same type,
 * we cannot make them into type refs. Or if any of the {@link Ref}
 * says they cannot be in type refs, we cannot do that either.
 *
 * TODO: just checking if the refs are the same is not suffice.
 * If two refs derive from each other, they cannot form a list of refs
 * (because of a possible ambiguity).
 */
private Mode canBeTypeRefs() {
    Set<NType> types = new HashSet<NType>();

    collectionMode = mul.isAtMostOnce()?NOT_REPEATED:REPEATED_ELEMENT;

    // the way we compute this is that we start from the most optimistic value,
    // and then gradually degrade as we find something problematic.
    Mode mode = Mode.SHOULD_BE_TYPEREF;

    for( Ref r : refs ) {
        mode = mode.or(r.canBeType(this));
        if(mode== Mode.MUST_BE_REFERENCE)
            return mode;    // no need to continue the processing

        if(!types.add(r.toTypeRef(null).getTarget().getType()))
            return Mode.MUST_BE_REFERENCE;   // collision
        if(r.isListOfValues()) {
            if(refs.size()>1 || !mul.isAtMostOnce())
                return Mode.MUST_BE_REFERENCE;   // restriction on @XmlList
            collectionMode = REPEATED_VALUE;
        }
    }
    return mode;
}
 

/**
 * Returns true if {@link #refs} can form refs of types.
 *
 * If there are multiple {@link Ref}s with the same type,
 * we cannot make them into type refs. Or if any of the {@link Ref}
 * says they cannot be in type refs, we cannot do that either.
 *
 * TODO: just checking if the refs are the same is not suffice.
 * If two refs derive from each other, they cannot form a list of refs
 * (because of a possible ambiguity).
 */
private Mode canBeTypeRefs() {
    Set<NType> types = new HashSet<NType>();

    collectionMode = mul.isAtMostOnce()?NOT_REPEATED:REPEATED_ELEMENT;

    // the way we compute this is that we start from the most optimistic value,
    // and then gradually degrade as we find something problematic.
    Mode mode = Mode.SHOULD_BE_TYPEREF;

    for( Ref r : refs ) {
        mode = mode.or(r.canBeType(this));
        if(mode== Mode.MUST_BE_REFERENCE)
            return mode;    // no need to continue the processing

        if(!types.add(r.toTypeRef(null).getTarget().getType()))
            return Mode.MUST_BE_REFERENCE;   // collision
        if(r.isListOfValues()) {
            if(refs.size()>1 || !mul.isAtMostOnce())
                return Mode.MUST_BE_REFERENCE;   // restriction on @XmlList
            collectionMode = REPEATED_VALUE;
        }
    }
    return mode;
}
 

/**
 * Returns true if {@link #refs} can form refs of types.
 *
 * If there are multiple {@link Ref}s with the same type,
 * we cannot make them into type refs. Or if any of the {@link Ref}
 * says they cannot be in type refs, we cannot do that either.
 *
 * TODO: just checking if the refs are the same is not suffice.
 * If two refs derive from each other, they cannot form a list of refs
 * (because of a possible ambiguity).
 */
private Mode canBeTypeRefs() {
    Set<NType> types = new HashSet<NType>();

    collectionMode = mul.isAtMostOnce()?NOT_REPEATED:REPEATED_ELEMENT;

    // the way we compute this is that we start from the most optimistic value,
    // and then gradually degrade as we find something problematic.
    Mode mode = Mode.SHOULD_BE_TYPEREF;

    for( Ref r : refs ) {
        mode = mode.or(r.canBeType(this));
        if(mode== Mode.MUST_BE_REFERENCE)
            return mode;    // no need to continue the processing

        if(!types.add(r.toTypeRef(null).getTarget().getType()))
            return Mode.MUST_BE_REFERENCE;   // collision
        if(r.isListOfValues()) {
            if(refs.size()>1 || !mul.isAtMostOnce())
                return Mode.MUST_BE_REFERENCE;   // restriction on @XmlList
            collectionMode = REPEATED_VALUE;
        }
    }
    return mode;
}
 

public NType getContentInMemoryType() {
    if(getProperty().getAdapter()==null) {
        NType itemType = getContentType().getType();
        if(!property.isCollection())
            return itemType;

        return NavigatorImpl.createParameterizedType(List.class,itemType);
    } else {
        return getProperty().getAdapter().customType;
    }
}
 

public NType getContentInMemoryType() {
    if(getProperty().getAdapter()==null) {
        NType itemType = getContentType().getType();
        if(!property.isCollection())
            return itemType;

        return NavigatorImpl.createParameterizedType(List.class,itemType);
    } else {
        return getProperty().getAdapter().customType;
    }
}
 

public NType getContentInMemoryType() {
    if(getProperty().getAdapter()==null) {
        NType itemType = getContentType().getType();
        if(!property.isCollection())
            return itemType;

        return NavigatorImpl.createParameterizedType(List.class,itemType);
    } else {
        return getProperty().getAdapter().customType;
    }
}
 

public Map<NType, ? extends CBuiltinLeafInfo> builtins() {
    return CBuiltinLeafInfo.LEAVES;
}
 

public CNonElement getTypeInfo(NType type) {
    CBuiltinLeafInfo leaf = CBuiltinLeafInfo.LEAVES.get(type);
    if(leaf!=null)      return leaf;

    return getClassInfo(getNavigator().asDecl(type));
}
 

public PropertyInfo<NType, NClass> getSource() {
    // TODO: implement this method later
    throw new UnsupportedOperationException();
}
 

public Element<NType,NClass> asElement() {
    if(isElement())
        return this;
    else
        return null;
}
 

public Element<NType,NClass> asElement() {
    return null;
}
 

public NType getType() {
    return this;
}
 

public CNonElement getTypeInfo(NType type) {
    CBuiltinLeafInfo leaf = CBuiltinLeafInfo.LEAVES.get(type);
    if(leaf!=null)      return leaf;

    return getClassInfo(getNavigator().asDecl(type));
}
 

public NType getType() {
    return this;
}
 

/**
 * @deprecated why are you calling a method that returns this?
 */
public NType getType() {
    return this;
}
 

private CBuiltinLeafInfo(NType typeToken, ID id, QName... typeNames) {
    this.type = typeToken;
    this.typeName = typeNames.length>0?typeNames[0]:null;
    this.typeNames = typeNames;
    this.id = id;
}
 

public Map<NType, ? extends CBuiltinLeafInfo> builtins() {
    return CBuiltinLeafInfo.LEAVES;
}
 

public NType getType() {
    return this;
}
 

public NonElement<NType,NClass> getBaseType() {
    return base;
}
 

public NType getType() {
    return this;
}
 

public NonElement<NType,NClass> getBaseType() {
    return base;
}
 

public PropertyInfo<NType, NClass> getSource() {
    // TODO: implement this method later
    throw new UnsupportedOperationException();
}
 

/**
 * A reference to the representation of the type.
 */
public NType getType() {
    return type;
}
 

/**
 * @deprecated always return null at this level.
 */
public final Element<NType,NClass> asElement() {
    return null;
}