com.sun.xml.xsom.XSFacet Java Examples

public Long getValue(XSFacet facet) {
	final XmlString value = facet.getValue();

	if (value == null) {
		return null;
	} else {
		final String v = value.value;

		if (v == null) {
			return null;
		} else {
			final BigInteger integerValue = DatatypeConverter.parseInteger(v);
			if (integerValue.compareTo(BigInteger
					.valueOf(Long.MAX_VALUE)) > 0) {
				return Long.MAX_VALUE;
			} else {
				return integerValue.longValue();
			}
		}
	}
}
 

/**
 * 
 * @param schemaSimpleType
 * @return
 */
public Vector<String> getSimpleTypeEnumeration ( SchemaSimpleType schemaSimpleType ) {

    Vector<String> enumeration = new Vector<String>();
    XSSimpleType st = parse( schemaSimpleType );

    XSRestrictionSimpleType restriction = st.asRestriction();

    if ( restriction != null ) {

        Iterator<? extends XSFacet> i = restriction.getDeclaredFacets().iterator();
        while (i.hasNext()) {
            XSFacet facet = i.next();

            if ( facet.getName().equals( XSFacet.FACET_ENUMERATION ) ) {
                enumeration.add( facet.getValue().value );
            }
        }
    }
    return enumeration;

}
 

private static boolean hasMinLength(XSRestrictionSimpleType xsRrestriction) {
  Iterator<XSFacet> facets = xsRrestriction.iterateDeclaredFacets();
  while (facets.hasNext()) {
    XSFacet facet = facets.next();
    String name = facet.getName();
    if ((XSFacet.FACET_LENGTH.equals(name) || XSFacet.FACET_MINLENGTH.equals(name))
        && Integer.parseInt(facet.getValue().toString()) > 0)
      return true;
  }
  return false;
}
 

private static boolean isEnumeration(XSRestrictionSimpleType xsRrestriction) {
  Iterator<XSFacet> facets = xsRrestriction.iterateDeclaredFacets();
  while (facets.hasNext())
    if (XSFacet.FACET_ENUMERATION.equals(facets.next().getName()))
      return true;
  return false;
}
 

public void restrictionSimpleType( XSRestrictionSimpleType type ) {

		if(type.getBaseType()==null) {
			// don't print anySimpleType
			if(!type.getName().equals("anySimpleType"))
				throw new InternalError();
			if(!Const.schemaNamespace.equals(type.getTargetNamespace()))
				throw new InternalError();
			return;
		}

		XSSimpleType baseType = type.getSimpleBaseType();

		println(MessageFormat.format("<restriction{0}>",
				baseType.isLocal()?"":" base=\"{"+
						baseType.getTargetNamespace()+'}'+
						baseType.getName()+'\"'));
		indent++;

		if(baseType.isLocal())
			simpleType(baseType);

		Iterator<XSFacet> itr = type.iterateDeclaredFacets();
		while(itr.hasNext())
			facet( (XSFacet)itr.next() );

		indent--;
		println("</restriction>");
	}
 

@Override
public void restrictionSimpleType(XSRestrictionSimpleType type) {
	final List<XSFacet> facets = type.getFacets(XSFacet.FACET_ENUMERATION);
	if (facets != null) {
		for (XSFacet facet : facets) {
			final XmlString value = facet.getValue();
			if (value != null) {
				this.values.add(value);
			}
		}
	}
}
 

public void restrictionSimpleType( XSRestrictionSimpleType type ) {

        if(type.getBaseType()==null) {
            // don't print anySimpleType
            if(!type.getName().equals("anySimpleType"))
                throw new InternalError();
            if(!Const.schemaNamespace.equals(type.getTargetNamespace()))
                throw new InternalError();
            return;
        }

        XSSimpleType baseType = type.getSimpleBaseType();

        println(MessageFormat.format("<restriction{0}>",
            baseType.isLocal()?"":" base=\"{"+
            baseType.getTargetNamespace()+'}'+
            baseType.getName()+'\"'));
        indent++;

        if(baseType.isLocal())
            simpleType(baseType);

        Iterator<XSFacet> itr = type.iterateDeclaredFacets();
        while(itr.hasNext())
            facet( (XSFacet)itr.next() );

        indent--;
		if (baseType.isLocal())
			println("</restriction>");
    }
 

public XSFacet getDeclaredFacet( String name ) {
    int len = facets.size();
    for( int i=0; i<len; i++ ) {
        XSFacet f = facets.get(i);
        if(f.getName().equals(name))
            return f;
    }
    return null;
}
 

public List<XSFacet> getDeclaredFacets(String name) {
    List<XSFacet> r = new ArrayList<XSFacet>();
    for( XSFacet f : facets )
        if(f.getName().equals(name))
            r.add(f);
    return r;
}
 

public XSFacet getFacet( String name ) {
    XSFacet f = getDeclaredFacet(name);
    if(f!=null)     return f;

    // none was found on this datatype. check the base type.
    return getSimpleBaseType().getFacet(name);
}
 

public void restrictionSimpleType(XSRestrictionSimpleType type) {

        if (type.getBaseType() == null) {
            // don't print anySimpleType
            if (!type.getName().equals("anySimpleType")) {
                throw new InternalError();
            }
            if (!Const.schemaNamespace.equals(type.getTargetNamespace())) {
                throw new InternalError();
            }
            return;
        }

        XSSimpleType baseType = type.getSimpleBaseType();

        String str = MessageFormat.format("Restriction {0}",
                new Object[]{baseType.isLocal() ? "" : " base=\"{"
                + baseType.getTargetNamespace() + "}"
                + baseType.getName() + "\""});

        SchemaTreeNode newNode = new SchemaTreeNode(str, baseType.getLocator());
        this.currNode.add(newNode);
        this.currNode = newNode;

        if (baseType.isLocal()) {
            simpleType(baseType);
        }

        Iterator itr = type.iterateDeclaredFacets();
        while (itr.hasNext()) {
            facet((XSFacet) itr.next());
        }

        this.currNode = (SchemaTreeNode) this.currNode.getParent();
    }
 

public void restrictionSimpleType( XSRestrictionSimpleType type ) {

        if(type.getBaseType()==null) {
            // don't print anySimpleType
            if(!type.getName().equals("anySimpleType"))
                throw new InternalError();
            if(!Const.schemaNamespace.equals(type.getTargetNamespace()))
                throw new InternalError();
            return;
        }

        XSSimpleType baseType = type.getSimpleBaseType();

        println(MessageFormat.format("<restriction{0}>",
            new Object[]{
                baseType.isLocal()?"":" base=\"{"+
                baseType.getTargetNamespace()+'}'+
                baseType.getName()+'\"'
            }));
        indent++;

        if(baseType.isLocal())
            simpleType(baseType);

        Iterator itr = type.iterateDeclaredFacets();
        while(itr.hasNext())
            facet( (XSFacet)itr.next() );

        indent--;
        println("</restriction>");
    }
 

public Iterator<XSFacet> simpleType(XSSimpleType type) {
    // TODO: it's not clear if "facets" mean all inherited facets or just declared facets
    XSRestrictionSimpleType r = type.asRestriction();
    if(r!=null)
        return r.iterateDeclaredFacets();
    else
        return empty();
}
 

private static void processRestrictions(XSRestrictionSimpleType xsRrestriction, Restrictions restrictions) {
  if (log.isDebugEnabled())
    log.debug("Restriction: " + xsRrestriction);

  Iterator<XSFacet> facets = xsRrestriction.iterateDeclaredFacets();
  while (facets.hasNext()) {
    XSFacet facet = facets.next();

    if (log.isDebugEnabled())
      log.debug("Facet: " + facet + " " + facet.getValue() + " Fixed: " + facet.isFixed());

    String facetName = facet.getName();
    String facetValue = facet.getValue().toString();
    
    // Enumeration
    
    if (XSFacet.FACET_ENUMERATION.equals(facetName))
      restrictions.getChoices().add(new ChoiceImpl(facetValue));
    
    // Length
    
    else if (XSFacet.FACET_LENGTH.equals(facetName))
      restrictions.setLength(Integer.parseInt(facetValue));
    else if (XSFacet.FACET_MINLENGTH.equals(facetName))
      restrictions.setMinLength(Integer.parseInt(facetValue));
    else if (XSFacet.FACET_MAXLENGTH.equals(facetName))
      restrictions.setMaxLength(Integer.parseInt(facetValue));
    
    // Number Range
    
    else if (XSFacet.FACET_MININCLUSIVE.equals(facetName))
      restrictions.setMinInclusive(readXmlValue(xsRrestriction, facetValue));
    else if (XSFacet.FACET_MINEXCLUSIVE.equals(facetName))
      restrictions.setMinExclusive(readXmlValue(xsRrestriction, facetValue));
    else if (XSFacet.FACET_MAXINCLUSIVE.equals(facetName))
      restrictions.setMaxInclusive(readXmlValue(xsRrestriction, facetValue));
    else if (XSFacet.FACET_MAXEXCLUSIVE.equals(facetName))
      restrictions.setMaxExclusive(readXmlValue(xsRrestriction, facetValue));
    
    else
      log.warn("Unsupported Facet: " + facetName);
  }
}
 

protected boolean match(XSFacet f) {
    return f.getName().equals(name);
}
 

public Facet(Axis<? extends XSFacet> axis, String facetName) {
    super(axis);
    this.name = facetName;
}
 

public Collection<? extends XSFacet> getDeclaredFacets() {
    return facets;
}
 

public Iterator<XSFacet> iterateDeclaredFacets() {
    return facets.iterator();
}
 

public void addFacet( XSFacet facet ) {
    facets.add(facet);
}
 

public XSFacet getFacet( String name ) { return null; } 

public XSFacet getFacet( String name ) { return null; } 

public List<XSFacet> getDeclaredFacets(String name) { return Collections.EMPTY_LIST; } 

public XSFacet getDeclaredFacet(String name) { return null; } 

public XSFacet getFacet(String name) { return null; } 

public Collection<? extends XSFacet> getDeclaredFacets() { return Collections.EMPTY_LIST; } 

public Iterator<XSFacet> iterateDeclaredFacets() { return Iterators.empty(); }