Java UProperty.INT_LIMIT属性代码示例

public int getIntPropertyValue(int c, int which) {
    if(which<UProperty.INT_START) {
        if(UProperty.BINARY_START<=which && which<UProperty.BINARY_LIMIT) {
            return binProps[which].contains(c) ? 1 : 0;
        }
    } else if(which<UProperty.INT_LIMIT) {
        return intProps[which-UProperty.INT_START].getValue(c);
    } else if (which == UProperty.GENERAL_CATEGORY_MASK) {
        return getMask(getType(c));
    }
    return 0; // undefined
}
 

public int getIntPropertyMaxValue(int which) {
    if(which<UProperty.INT_START) {
        if(UProperty.BINARY_START<=which && which<UProperty.BINARY_LIMIT) {
            return 1;  // maximum TRUE for all binary properties
        }
    } else if(which<UProperty.INT_LIMIT) {
        return intProps[which-UProperty.INT_START].getMaxValue(which);
    }
    return -1; // undefined
}
 

@SuppressWarnings("deprecation")
@Test
public void testLimits() {
    // integer valued properties
    for (int p = UProperty.INT_START; p < UProperty.INT_LIMIT; ++p) {
        int min = UCharacter.getIntPropertyMinValue(p);
        int max = UCharacter.getIntPropertyMaxValue(p);

        assertTrue(String.format("min=%d", min), min >= 0);
        assertTrue(String.format("min=%d, max=%d", min, max), min <= max);
        assertTrue(String.format("max=%d", max), max < 512); // BINARY_MASK in UEncoding
    }
}
 

public final int getSource(int which) {
    if(which<UProperty.BINARY_START) {
        return SRC_NONE; /* undefined */
    } else if(which<UProperty.BINARY_LIMIT) {
        return binProps[which].getSource();
    } else if(which<UProperty.INT_START) {
        return SRC_NONE; /* undefined */
    } else if(which<UProperty.INT_LIMIT) {
        return intProps[which-UProperty.INT_START].getSource();
    } else if(which<UProperty.STRING_START) {
        switch(which) {
        case UProperty.GENERAL_CATEGORY_MASK:
        case UProperty.NUMERIC_VALUE:
            return SRC_CHAR;

        default:
            return SRC_NONE;
        }
    } else if(which<UProperty.STRING_LIMIT) {
        switch(which) {
        case UProperty.AGE:
            return SRC_PROPSVEC;

        case UProperty.BIDI_MIRRORING_GLYPH:
            return SRC_BIDI;

        case UProperty.CASE_FOLDING:
        case UProperty.LOWERCASE_MAPPING:
        case UProperty.SIMPLE_CASE_FOLDING:
        case UProperty.SIMPLE_LOWERCASE_MAPPING:
        case UProperty.SIMPLE_TITLECASE_MAPPING:
        case UProperty.SIMPLE_UPPERCASE_MAPPING:
        case UProperty.TITLECASE_MAPPING:
        case UProperty.UPPERCASE_MAPPING:
            return SRC_CASE;

        case UProperty.ISO_COMMENT:
        case UProperty.NAME:
        case UProperty.UNICODE_1_NAME:
            return SRC_NAMES;

        default:
            return SRC_NONE;
        }
    } else {
        switch(which) {
        case UProperty.SCRIPT_EXTENSIONS:
            return SRC_PROPSVEC;
        default:
            return SRC_NONE; /* undefined */
        }
    }
}
 

/**
 * Constructor
 * @exception IOException thrown when data reading fails or data corrupted
 */
private UCharacterProperty() throws IOException
{
    // consistency check
    if(binProps.length!=UProperty.BINARY_LIMIT) {
        throw new ICUException("binProps.length!=UProperty.BINARY_LIMIT");
    }
    if(intProps.length!=(UProperty.INT_LIMIT-UProperty.INT_START)) {
        throw new ICUException("intProps.length!=(UProperty.INT_LIMIT-UProperty.INT_START)");
    }

    // jar access
    ByteBuffer bytes=ICUBinary.getRequiredData(DATA_FILE_NAME_);
    m_unicodeVersion_ = ICUBinary.readHeaderAndDataVersion(bytes, DATA_FORMAT, new IsAcceptable());
    // Read or skip the 16 indexes.
    int propertyOffset = bytes.getInt();
    /* exceptionOffset = */ bytes.getInt();
    /* caseOffset = */ bytes.getInt();
    int additionalOffset = bytes.getInt();
    int additionalVectorsOffset = bytes.getInt();
    m_additionalColumnsCount_ = bytes.getInt();
    int scriptExtensionsOffset = bytes.getInt();
    int reservedOffset7 = bytes.getInt();
    /* reservedOffset8 = */ bytes.getInt();
    /* dataTopOffset = */ bytes.getInt();
    m_maxBlockScriptValue_ = bytes.getInt();
    m_maxJTGValue_ = bytes.getInt();
    ICUBinary.skipBytes(bytes, (16 - 12) << 2);

    // read the main properties trie
    m_trie_ = Trie2_16.createFromSerialized(bytes);
    int expectedTrieLength = (propertyOffset - 16) * 4;
    int trieLength = m_trie_.getSerializedLength();
    if(trieLength > expectedTrieLength) {
        throw new IOException("uprops.icu: not enough bytes for main trie");
    }
    // skip padding after trie bytes
    ICUBinary.skipBytes(bytes, expectedTrieLength - trieLength);

    // skip unused intervening data structures
    ICUBinary.skipBytes(bytes, (additionalOffset - propertyOffset) * 4);

    if(m_additionalColumnsCount_ > 0) {
        // reads the additional property block
        m_additionalTrie_ = Trie2_16.createFromSerialized(bytes);
        expectedTrieLength = (additionalVectorsOffset-additionalOffset)*4;
        trieLength = m_additionalTrie_.getSerializedLength();
        if(trieLength > expectedTrieLength) {
            throw new IOException("uprops.icu: not enough bytes for additional-properties trie");
        }
        // skip padding after trie bytes
        ICUBinary.skipBytes(bytes, expectedTrieLength - trieLength);

        // additional properties
        int size = scriptExtensionsOffset - additionalVectorsOffset;
        m_additionalVectors_ = ICUBinary.getInts(bytes, size, 0);
    }

    // Script_Extensions
    int numChars = (reservedOffset7 - scriptExtensionsOffset) * 2;
    if(numChars > 0) {
        m_scriptExtensions_ = ICUBinary.getChars(bytes, numChars, 0);
    }
}