Java XMLChar.isSpace方法代码示例

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
private void scanCharReference() throws IOException {
	fStringBuffer2.clear();
	boolean hex = entityScanner.peekChar() == 'x';
	int ch = scanCharReferenceValue(fStringBuffer2, null);
	if (ch != -1) {
		int c = Integer.valueOf(fStringBuffer3.toString(), hex ? 16 : 10);
		if (c < 0x20 && !XMLChar.isSpace(c)) {
			return;
		}
		if (hex) {//
			appendCharacter("&x");
		} else {
			appendCharacter("&");
		}
		appendCharacter(fStringBuffer3.toString());
		appendCharacter(";");
	} else {
		appendCharacter("&amp;#");
		appendCharacter(fStringBuffer3.toString());
	}
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
private boolean isWhitespace(Chars data){
    char chars[] = data.array();
    int end = data.offset()+data.length();
    for(int i=data.offset(); i<end; i++){
        if(!XMLChar.isSpace(chars[i]))
            return false;
    }
    return true;
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
/**
 * @see javax.xml.stream.events.Characters#isWhiteSpace()
 */
public boolean isWhiteSpace() {
    final int length = fData != null ? fData.length() : 0;
    if (length == 0) {
        return false;
    }
    for (int i = 0; i < length; ++i) {
        if (!XMLChar.isSpace(fData.charAt(i))) {
            return false;
        }
    }
    return true; 
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
/**
 * Normalize whitespace in an XMLString converting all whitespace
 * characters to space characters.
 */
protected void normalizeWhitespace(XMLString value) {
    int end = value.offset + value.length;
    for (int i = value.offset; i < end; ++i) {
        int c = value.ch[i];
        if (XMLChar.isSpace(c)) {
            value.ch[i] = ' ';
        }
    }
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
/**
 * Checks whether this string would be unchanged by normalization.
 * 
 * @return -1 if the value would be unchanged by normalization,
 * otherwise the index of the first whitespace character which
 * would be transformed.
 */
protected int isUnchangedByNormalization(XMLString value) {
    int end = value.offset + value.length;
    for (int i = value.offset; i < end; ++i) {
        int c = value.ch[i];
        if (XMLChar.isSpace(c)) {
            return i - value.offset;
        }
    }
    return -1;
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
/**
 * Character content.
 * 
 * @param text   The content.
 * @param augs   Additional information that may include infoset augmentations
 *               
 * @exception XNIException
 *                   Thrown by handler to signal an error.
 */
public void characters(XMLString text, Augmentations augs) throws XNIException {
    // when it's not within xs:appinfo or xs:documentation
    if (fInnerAnnotationDepth == -1 ) {
        for (int i=text.offset; i<text.offset+text.length; i++) {
            // and there is a non-whitespace character
            if (!XMLChar.isSpace(text.ch[i])) {
                // the string we saw: starting from the first non-whitespace character.
                String txt = new String(text.ch, i, text.length+text.offset-i);
                // report an error
                fErrorReporter.reportError(fLocator, 
                        XSMessageFormatter.SCHEMA_DOMAIN,
                        "s4s-elt-character",
                        new Object[]{txt},
                        XMLErrorReporter.SEVERITY_ERROR);
                break;
            }
        }
        // don't call super.characters() when it's not within one of the 2
        // annotation elements: the traversers ignore them anyway. We can
        // save time/memory creating the text nodes.
    }
    // when it's within either of the 2 elements, characters are allowed
    // and we need to store them.
    else {
        schemaDOM.characters(text);
    }
    
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
public boolean characterData(String data, Augmentations augs) {

        fSawText = fSawText || data.length() > 0;

        // REVISIT: this methods basically duplicates implementation of
        //          handleCharacters(). We should be able to reuse some code

        // if whitespace == -1 skip normalization, because it is a complexType
        // or a union type.
        if (fNormalizeData && fWhiteSpace != -1 && fWhiteSpace != XSSimpleType.WS_PRESERVE) {
            // normalize data
            normalizeWhitespace(data, fWhiteSpace == XSSimpleType.WS_COLLAPSE);
            fBuffer.append(fNormalizedStr.ch, fNormalizedStr.offset, fNormalizedStr.length);
        } else {
            if (fAppendBuffer)
                fBuffer.append(data);
        }

        // When it's a complex type with element-only content, we need to
        // find out whether the content contains any non-whitespace character.
        boolean allWhiteSpace = true;
        if (fCurrentType != null
            && fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
            XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
            if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_ELEMENT) {
                // data outside of element content
                for (int i = 0; i < data.length(); i++) {
                    if (!XMLChar.isSpace(data.charAt(i))) {
                        allWhiteSpace = false;
                        fSawCharacters = true;
                        break;
                    }
                }
            }
        }

        return allWhiteSpace;
    }
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
XMLString handleCharacters(XMLString text) {

        if (fSkipValidationDepth >= 0)
            return text;

        fSawText = fSawText || text.length > 0;

        // Note: data in EntityRef and CDATA is normalized as well
        // if whitespace == -1 skip normalization, because it is a complexType
        // or a union type.
        if (fNormalizeData && fWhiteSpace != -1 && fWhiteSpace != XSSimpleType.WS_PRESERVE) {
            // normalize data
            normalizeWhitespace(text, fWhiteSpace == XSSimpleType.WS_COLLAPSE);
            text = fNormalizedStr;
        }
        if (fAppendBuffer)
            fBuffer.append(text.ch, text.offset, text.length);

        // When it's a complex type with element-only content, we need to
        // find out whether the content contains any non-whitespace character.
        if (fCurrentType != null
            && fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
            XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
            if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_ELEMENT) {
                // data outside of element content
                for (int i = text.offset; i < text.offset + text.length; i++) {
                    if (!XMLChar.isSpace(text.ch[i])) {
                        fSawCharacters = true;
                        break;
                    }
                }
            }
        }

        return text;
    }
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
private void normalizeWhitespace(String value, boolean collapse) {
    boolean skipSpace = collapse;
    char c;
    int size = value.length();

    // ensure the ch array is big enough
    if (fNormalizedStr.ch == null || fNormalizedStr.ch.length < size) {
        fNormalizedStr.ch = new char[size];
    }
    fNormalizedStr.offset = 0;
    fNormalizedStr.length = 0;

    for (int i = 0; i < size; i++) {
        c = value.charAt(i);
        if (XMLChar.isSpace(c)) {
            if (!skipSpace) {
                // take the first whitespace as a space and skip the others
                fNormalizedStr.ch[fNormalizedStr.length++] = ' ';
                skipSpace = collapse;
            }
        } else {
            fNormalizedStr.ch[fNormalizedStr.length++] = c;
            skipSpace = false;
        }
    }
    if (skipSpace) {
        if (fNormalizedStr.length != 0)
            // if we finished on a space trim it but also record it
            fNormalizedStr.length--;
    }
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
/** Fixup XPath expression. Avoid creating a new String if possible. */
private static String fixupXPath(String xpath) {
    
    final int end = xpath.length();
    int offset = 0;
    boolean whitespace = true;
    char c;
    
    // NOTE: We have to prefix the field XPath with "./" in
    //       order to handle selectors such as "@attr" that 
    //       select the attribute because the fields could be
    //       relative to the selector element. -Ac
    //       Unless xpath starts with a descendant node -Achille Fokoue
    //      ... or a / or a . - NG
    for (; offset < end; ++offset) {
        c = xpath.charAt(offset);
        if (whitespace) {
            if (!XMLChar.isSpace(c)) {
                if (c == '.' || c == '/') {
                    whitespace = false;
                }
                else if (c != '|') {
                    return fixupXPath2(xpath, offset, end);
                }
            }
        }
        else if (c == '|') {
            whitespace = true;
        }
    }
    return xpath;
    
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
private static String fixupXPath2(String xpath, int offset, final int end) {

     StringBuffer buffer = new StringBuffer(end + 2);
     for (int i = 0; i < offset; ++i) {
         buffer.append(xpath.charAt(i));
     }
     buffer.append("./");
     
     boolean whitespace = false;
     char c;
     
     for (; offset < end; ++offset) {
         c = xpath.charAt(offset);
         if (whitespace) {
             if (!XMLChar.isSpace(c)) {
                 if (c == '.' || c == '/') {
                     whitespace = false;
                 }
                 else if (c != '|') {
                     buffer.append("./");
                     whitespace = false;
                 }
             }
         }
         else if (c == '|') {
             whitespace = true;
         }
         buffer.append(c);
     }
     return buffer.toString();
     
 }
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
/**
 * Normalize whitespace in an XMLString converting all whitespace
 * characters to space characters.
 */
protected void normalizeWhitespace(XMLString value, int fromIndex) {
    int end = value.offset + value.length;
    for (int i = value.offset + fromIndex; i < end; ++i) {
        int c = value.ch[i];
        if (XMLChar.isSpace(c)) {
            value.ch[i] = ' ';
        }
    }
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
/**
 * Checks whether the string only contains white space characters.
 * 
 * @param value the text to check
 */
private void checkWhitespace(XMLString value) {
    int end = value.offset + value.length;
    for (int i = value.offset; i < end; ++i) {
        if (!XMLChar.isSpace(value.ch[i])) {
            reportFatalError("ContentIllegalAtTopLevel");
            return;
        }
    }
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
public boolean isTextAccept(QName qname, XMLString content) {
	boolean spaces = true;
	for (int i = content.offset; i < content.offset + content.length; i++) {
		spaces = spaces &&  XMLChar.isSpace(content.ch[i]);
	}
	if (spaces) {
		return true;
	}
	return acceptText.containsSymbol(qname.rawname);
}
 

import org.apache.xerces.util.XMLChar; //导入方法依赖的package包/类
boolean skipSpaces() throws IOException, TmxEndEntityException {
	if (entity.position == entity.count) {
		load(0);
	}
	int c = entity.ch[entity.position];
	if (XMLChar.isSpace(c)) {
		do {
			boolean finish = false;
			if (c == '\n' || c == '\r') {
				entity.lineNumber++;
				entity.columnNumber = 1;
				if (entity.position == entity.count - 1) {
					entity.ch[0] = (char) c;
					finish = load(1);
					if (!finish) {
						entity.position = 0;
						entity.startPosition = 0;
					}
				}
				if (c == '\r') {
					if (entity.ch[++entity.position] != '\n'){
						entity.position--;
					}
				}
			} else {
				entity.columnNumber++;
			}
			if (!finish) entity.position++;
			if (entity.position == entity.count) {
				load(0);
			}
		} while (XMLChar.isSpace(c = entity.ch[entity.position]));
		return true;
	}
	return false;
}