Eu achei na internet um código intitulado "DatatypeConverter.java", mostrado a seguir:
-------------------------------- Início do código DatatypeConverter.java -------------------------------------------------
[code]/*
* Copyright 2003, 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package javax.xml.bind;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Calendar;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
/**
This is a helper class for customized datatypes. It provides a
* set of static methods which may be useful in custom methods for
* parsing and printing values.
*
The JAXB provider is responsible to initialize the
* DatatypeConverter class by invoking
* {@link #setDatatypeConverter(DatatypeConverterInterface)} as soon
* as possible.
*
* @author JSR-31
* @since JAXB1.0
*/
public final class DatatypeConverter {
private static DatatypeConverterInterface converter;
/**
This method must be invoked by the JAXB provider to set the actual
* instance, which is invoked by the static methods. Subsequent
* invocations of the method are ignored: First come, first wins.
* @throws IllegalArgumentException The parameter was null.
*/
public static void setDatatypeConverter(DatatypeConverterInterface pConverter) {
if (pConverter == null) {
throw new IllegalArgumentException("The parameter must not be null.");
}
synchronized (DatatypeConverter.class) {
if (converter == null) {
converter = pConverter;
}
}
}
/**
Parses the lexical representation and converts it into a String.
*
* @param pLexicalXSDString The input string being parsed.
* @return The unmodified input string.
* @see javax.xml.bind.ParseConversionEvent
*/
public static String parseString(String pLexicalXSDString) {
return converter.parseString(pLexicalXSDString);
}
/**
Parses the lexical representation of the given integer value
* (arbitrary precision) and converts it into an instance of
* {@link java.math.BigInteger}.
* @param pLexicalXSDInteger The input string being parsed.
* @return The input string converted into an instance of {@link BigInteger}.
* @see javax.xml.bind.ParseConversionEvent
*/
public static BigInteger parseInteger(String pLexicalXSDInteger) {
return converter.parseInteger(pLexicalXSDInteger);
}
/**
Parses the lexical representation of the given 32 bit integer value
* and converts it into a primitive int value.
* @param pLexicalXSDInt The input string being parsed.
* @return The input string converted into a primitive
int.
* @see javax.xml.bind.ParseConversionEvent
*/
public static int parseInt(String pLexicalXSDInt) {
return converter.parseInt(pLexicalXSDInt);
}
/**
Parses the lexical representation of the given 64 bit integer value
* and converts it into a primitive long value.
* @param pLexicalXSDLong The input string being parsed.
* @return The input string converted into a primitive
long.
* @see javax.xml.bind.ParseConversionEvent
*/
public static long parseLong(String pLexicalXSDLong) {
return converter.parseLong(pLexicalXSDLong);
}
/**
Parses the lexical representation of the given 16 bit integer value
* and converts it into a primitive short value.
* @param pLexicalXSDShort The input string being parsed.
* @return The input string converted into a primitive
short.
* @see javax.xml.bind.ParseConversionEvent
*/
public static short parseShort(String pLexicalXSDShort) {
return converter.parseShort(pLexicalXSDShort);
}
/**
Parses the lexical representation of the given decimal value
* (arbitrary precision) and converts it into an instance of
* {@link java.math.BigDecimal}.
* @param pLexicalXSDDecimal The input string being parsed.
* @return The input string converted into an instance of {@link java.math.BigDecimal}.
* @see javax.xml.bind.ParseConversionEvent
*/
public static BigDecimal parseDecimal(String pLexicalXSDDecimal) {
return converter.parseDecimal(pLexicalXSDDecimal);
}
/**
Parses the lexical representation of the given 32 bit floating
* point value and converts it into a primitive float value.
* @param pLexicalXSDFloat The input string being parsed.
* @return The input string converted into a primitive
float.
* @see javax.xml.bind.ParseConversionEvent
*/
public static float parseFloat(String pLexicalXSDFloat) {
return converter.parseFloat(pLexicalXSDFloat);
}
/**
Parses the lexical representation of the given 64 bit floating
* point value and converts it into a primitive double value.
* @param pLexicalXSDDouble The input string being parsed.
* @return The input string converted into a primitive
double.
* @see javax.xml.bind.ParseConversionEvent
*/
public static double parseDouble(String pLexicalXSDDouble) {
return converter.parseDouble(pLexicalXSDDouble);
}
/**
Parses the lexical representation of the given boolean value
* and converts it into a primitive boolean value.
* @param pLexicalXSDBoolean The input string being parsed.
* @return The input string converted into a primitive
boolean.
* @see javax.xml.bind.ParseConversionEvent
*/
public static boolean parseBoolean(String pLexicalXSDBoolean) {
return converter.parseBoolean(pLexicalXSDBoolean);
}
/**
Parses the lexical representation of the given 8 bit integer value
* and converts it into a primitive byte value.
* @param pLexicalXSDByte The input string being parsed.
* @return The input string converted into a primitive
byte.
* @see javax.xml.bind.ParseConversionEvent
*/
public static byte parseByte(String pLexicalXSDByte) {
return converter.parseByte(pLexicalXSDByte);
}
/**
Parses the lexical representation of the given qualified name
* and converts it into an instance of {@link javax.xml.namespace.QName}.
* The {@link javax.xml.namespace.QName} consists of a namespace URI
* and a local name.
* @param pLexicalXSDQName The input string being parsed, an optional
* namespace prefix, followed by the local name, if any. If a prefix
* is present, they are separated by a colon.
* @param pNamespaceContext The namespace context is used to query
* mappings between prefixes and namespace URI's.
* @return The input string converted into an instance of
* {@link javax.xml.namespace.QName}.
* @see javax.xml.bind.ParseConversionEvent
*/
public static QName parseQName(String pLexicalXSDQName,
NamespaceContext pNamespaceContext) {
return converter.parseQName(pLexicalXSDQName, pNamespaceContext);
}
/**
Parses the lexical representation of the given dateTime value
* and converts it into an instance of {@link java.util.Calendar}.
* Valid lexical representations of a dateTime value include
*
* YYYY-MM-DDThh:mm:ss
* YYYY-MM-DDThh:mm:ss.sss
* YYYY-MM-DDThh:mm:ssZ
* YYYY-MM-DDThh:mm:ss-01:00
*
* The former examples are all specified in UTC time. The last example
* uses a negatice offset of one hour to UTC.
* @param pLexicalXSDDateTime The input string being parsed.
* @return The input string converted into an instance of
* {@link java.util.Calendar}.
* @see javax.xml.bind.ParseConversionEvent
*/
public static Calendar parseDateTime(String pLexicalXSDDateTime) {
return converter.parseDateTime(pLexicalXSDDateTime);
}
/** Parses the lexical representation of the given byte array, which
* is encoded in base 64.
* @param pLexicalXSDBase64Binary The input string being parsed, a
* base 64 encoded array of bytes.
* @return The decoded byte array.
* @see javax.xml.bind.ParseConversionEvent
*/
[color=red] public static byte[] parseBase64Binary(String pLexicalXSDBase64Binary) {
return converter.parseBase64Binary(pLexicalXSDBase64Binary);[/color]
}
/**
Parses the lexical representation of the given byte array, which
* is encoded in hex digits.
* @param pLexicalXSDHexBinary The input string being parsed, an
* array of bytes encoded in hex digits.
* @return The decoded byte array.
* @see javax.xml.bind.ParseConversionEvent
*/
public static byte[] parseHexBinary(String pLexicalXSDHexBinary) {
return converter.parseHexBinary(pLexicalXSDHexBinary);
}
/**
Parses the lexical representation of the given 32 bit
* unsignet integer value and converts it into a primitive long
* value.
* @param pLexicalXSDUnsignedInt The input string being parsed.
* @return The input string converted into a primitive
long.
* @see javax.xml.bind.ParseConversionEvent
*/
public static long parseUnsignedInt(String pLexicalXSDUnsignedInt) {
return converter.parseUnsignedInt(pLexicalXSDUnsignedInt);
}
/**
Parses the lexical representation of the given 16 bit
* unsignet integer value and converts it into a primitive int
* value.
* @param pLexicalXSDUnsignedShort The input string being parsed.
* @return The input string conve
* rted into a primitive
int.
* @see javax.xml.bind.ParseConversionEvent
*/
public static int parseUnsignedShort(String pLexicalXSDUnsignedShort) {
return converter.parseUnsignedShort(pLexicalXSDUnsignedShort);
}
/**
Parses the lexical representation of the given time value
* and converts it into an instance of {@link java.util.Calendar}.
* Valid lexical representations of a time value include
*
* hh:mm:ss
* hh:mm:ss.sss
* hh:mm:ssZ
* hh:mm:ss-01:00
*
* The former examples are all specified in UTC time. The last example
* uses a negatice offset of one hour to UTC.
* @param pLexicalXSDTime The input string being parsed.
* @return The input string converted into an instance of
* {@link java.util.Calendar}.
* @see javax.xml.bind.ParseConversionEvent
*/
public static Calendar parseTime(String pLexicalXSDTime) {
return converter.parseTime(pLexicalXSDTime);
}
/**
Parses the lexical representation of the given date value
* and converts it into an instance of {@link java.util.Calendar}.
* Valid lexical representations of a date value include
*
* YYYY-MM-DD
* YYYY-MM-DDZ
* YYYY-MM-DD-01:00
*
* The former examples are all specified in UTC time. The last example
* uses a negatice offset of one hour to UTC.
* @param pLexicalXSDDate The input string being parsed.
* @return The input string converted into an instance of
* {@link java.util.Calendar}.
* @see javax.xml.bind.ParseConversionEvent
*/
public static Calendar parseDate(String pLexicalXSDDate) {
return converter.parseDate(pLexicalXSDDate);
}
/**
Returns the lexical representation of the input string, which is
* the unmodified input string.
* @param pLexicalXSDAnySimpleType An input string in lexical representation.
* @return The unmodified input string.
* @see javax.xml.bind.ParseConversionEvent
*/
public static String parseAnySimpleType(String pLexicalXSDAnySimpleType) {
return converter.parseAnySimpleType(pLexicalXSDAnySimpleType);
}
/**
Returns a lexical representation of the given input string, which
* is the unmodified input string.
* @param pValue The input string.
* @return The unmodified input string.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printString(String pValue) {
return converter.printString(pValue);
}
/**
Returns a lexical representation of the given instance of
* {@link BigInteger}, which is an integer in arbitrary precision.
* @param pValue The integer value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printInteger(BigInteger pValue) {
return converter.printInteger(pValue);
}
/**
Returns a lexical representation of the given primitive
* 32 bit integer.
* @param pValue The
int value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printInt(int pValue) {
return converter.printInt(pValue);
}
/**
Returns a lexical representation of the given primitive
* 64 bit integer.
* @param pValue The
long value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printLong(long pValue) {
return converter.printLong(pValue);
}
/**
Returns a lexical representation of the given primitive
* 16 bit integer.
* @param pValue The
short value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printShort(short pValue) {
return converter.printShort(pValue);
}
/**
Returns a lexical representation of the given instance of
* {@link BigDecimal}, which is a decimal number in arbitrary
* precision.
* @param pValue The decimal value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printDecimal(BigDecimal pValue) {
return converter.printDecimal(pValue);
}
/**
Returns a lexical representation of the given primitive
* 32 bit floating point number.
* @param pValue The
float value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printFloat(float pValue) {
return converter.printFloat(pValue);
}
/**
Returns a lexical representation of the given primitive
* 64 bit floating point number.
* @param pValue The
double value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printDouble(double pValue) {
return converter.printDouble(pValue);
}
/**
Returns a lexical representation of the given primitive
* boolean value.
* @param pValue The
boolean value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printBoolean(boolean pValue) {
return converter.printBoolean(pValue);
}
/**
Returns a lexical representation of the given primitive
* 8 bit integer.
* @param pValue The
byte value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printByte(byte pValue) {
return converter.printByte(pValue);
}
/**
Returns a lexical representation of the given qualified
* name, which is a combination of namespace URI and local name.
* The lexical representation is an optional prefix, which is
* currently mapped to namespace URI of the qualified name,
* followed by a colon and the local name. If the namespace URI
* is the current default namespace URI, then the prefix and
* the colon may be omitted.
* @param pValue The qualified name being converted.
* @param pNamespaceContext A mapping of prefixes to namespace
* URI's which may be used to determine a valid prefix.
* @return A lexical representation of the qualified name.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printQName(QName pValue,
NamespaceContext pNamespaceContext) {
return converter.printQName(pValue, pNamespaceContext);
}
/**
Returns a lexical representation of the given dateTime
* value. Valid lexical representations include:
*
* YYYY-MM-DDThh:mm:ss
* YYYY-MM-DDThh:mm:ss.sss
* YYYY-MM-DDThh:mm:ssZ
* YYYY-MM-DDThh:mm:ss-01:00
*
* The former examples are all specified in UTC time. The last example
* uses a negatice offset of one hour to UTC.
* @param pValue The dateTime value being converted
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printDateTime(Calendar pValue) {
return converter.printDateTime(pValue);
}
/**
Returns a lexical representation of the given byte array.
* The lexical representation is obtained by application of the
* base 64 encoding.
* @param pValue The byte array being converted.
* @return The converted byte array.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printBase64Binary(byte[] pValue) {
return converter.printBase64Binary(pValue);
}
/**
Returns a lexical representation of the given byte array.
* The lexical representation is obtained by encoding any byte
* as two hex digits.
* @param pValue The byte array being converted.
* @return The converted byte array.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printHexBinary(byte[] pValue) {
return converter.printHexBinary(pValue);
}
/**
Returns a lexical representation of the given primitive,
* unsigned 32 bit integer.
* @param pValue The
long value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printUnsignedInt(long pValue) {
return converter.printUnsignedInt(pValue);
}
/**
Returns a lexical representation of the given primitive,
* unsigned 16 bit integer.
* @param pValue The
short value being converted.
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printUnsignedShort(int pValue) {
return converter.printUnsignedShort(pValue);
}
/**
Returns a lexical representation of the given time
* value. Valid lexical representations include:
*
* hh:mm:ss
* hh:mm:ss.sss
* hh:mm:ssZ
* hh:mm:ss-01:00
*
* The former examples are all specified in UTC time. The last example
* uses a negatice offset of one hour to UTC.
* @param pValue The time value being converted
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printTime(Calendar pValue) {
return converter.printTime(pValue);
}
/**
Returns a lexical representation of the given date
* value. Valid lexical representations include:
*
* YYYY-MM-DD
* YYYY-MM-DDZ
* YYYY-MM-DD-01:00
*
* The former examples are all specified in UTC time. The last example
* uses a negatice offset of one hour to UTC.
* @param pValue The date value being converted
* @return A lexical representation of the input value.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printDate(Calendar pValue) {
return converter.printDate(pValue);
}
/**
Returns a lexical representation of the given input
* string, which is the unmodified input string.
* @param pValue The input string.
* @return The unmodified input string.
* @see javax.xml.bind.PrintConversionEvent
*/
public static String printAnySimpleType(String pValue) {
return converter.printAnySimpleType(pValue);
}
}
-------------------------------- Fimdo código DatatypeConverter.java -------------------------------------------------
Eu entendi o código acima como uma biblioteca. Assim sendo, fiz o seguinte código intitulado "testeBase64":
-------------------------------- Início do código testeBase64 ------------------------------------------------------------
import DatatypeConverter.*;
public class testeBase64 {
public static void main(String[] args) {
//String em base64 para ser convertida:
String encoded = "TWFyeSBoYWQgYSBsaXR0bGUgbGFtYi4u";
//Fazendo a conversão de base64 para ASCII:
byte[] retorno = parseBase64Binary(encoded);
}
}
-------------------------------- Fim do código testeBase64 ------------------------------------------------------------
Depois, eu utilizei o comando "javac testeBase64.java", mas apareceu a seguinte mensagem de erro:
testeBase64.java:1: error: package DatatypeConverter does not exist
import DatatypeConverter.*;
^
testeBase64.java:8: error: cannot find symbol
byte[] retorno = parseBase64Binary(encoded);
^
symbol: method parseBase64Binary(String)
location: class testeBase64
2 errors
Ou seja, não sei como utilizar ou incorporar a função "parseBase64Binary", contida no arquivo "DatatypeConverter.java", em outro código.
Como faço para testar a função citada?
Muito obrigado!
