/**
* @return an instanciation of the given content-type class name, or null if class wasn't found
*/
public static ContentType getContentTypeFromClassName(String contentTypeClassName) {
if (contentTypeClassName == null)
contentTypeClassName = getAvailableContentTypes()[DEFAULT_CONTENT_TYPE_INDEX];
ContentType ct = null;
try {
Class clazz = Class.forName(contentTypeClassName);
ct = (ContentType) clazz.newInstance();
} catch (ClassNotFoundException cnfex) {
if (jpicedt.Log.DEBUG) cnfex.printStackTrace();
JPicEdt.getMDIManager()
.showMessageDialog(
"The pluggable content-type you asked for (class "
+ cnfex.getLocalizedMessage()
+ ") isn't currently installed, using default instead...",
Localizer.currentLocalizer().get("msg.LoadingContentTypeClass"),
JOptionPane.ERROR_MESSAGE);
} catch (Exception ex) {
if (jpicedt.Log.DEBUG) ex.printStackTrace();
JPicEdt.getMDIManager()
.showMessageDialog(
ex.getLocalizedMessage(),
Localizer.currentLocalizer().get("msg.LoadingContentTypeClass"),
JOptionPane.ERROR_MESSAGE);
}
return ct;
}
/** Determine whether the current user has Windows administrator privileges. */
public static boolean isWinAdmin() {
if (!isWinPlatform()) return false;
// for (String group : new com.sun.security.auth.module.NTSystem().getGroupIDs()) {
// if (group.equals("S-1-5-32-544")) return true; // "S-1-5-32-544" is a well-known
// security identifier in Windows. If the current user has it then he/she/it is an
// administrator.
// }
// return false;
try {
Class<?> ntsys = Class.forName("com.sun.security.auth.module.NTSystem");
if (ntsys != null) {
Object groupObj =
SystemUtils.invoke(
ntsys.newInstance(), ntsys.getDeclaredMethod("getGroupIDs"), (Object[]) null);
if (groupObj instanceof String[]) {
for (String group : (String[]) groupObj) {
if (group.equals("S-1-5-32-544"))
return true; // "S-1-5-32-544" is a well-known security identifier in Windows. If the
// current user has it then he/she/it is an administrator.
}
}
}
} catch (ReflectiveOperationException e) {
System.err.println(e);
}
return false;
}
/**
* Examines a property's type to see which method should be used to parse the property's value.
*
* @param desc The description of the property
* @param value The value of the XML attribute containing the prop value
* @return The value stored in the element
* @throws IOException If there is an error reading the document
*/
public Object getObjectValue(PropertyDescriptor desc, String value) throws IOException {
// Find out what kind of property it is
Class type = desc.getPropertyType();
// If it's an array, get the base type
if (type.isArray()) {
type = type.getComponentType();
}
// For native types, object wrappers for natives, and strings, use the
// basic parse routine
if (type.equals(Integer.TYPE)
|| type.equals(Long.TYPE)
|| type.equals(Short.TYPE)
|| type.equals(Byte.TYPE)
|| type.equals(Boolean.TYPE)
|| type.equals(Float.TYPE)
|| type.equals(Double.TYPE)
|| Integer.class.isAssignableFrom(type)
|| Long.class.isAssignableFrom(type)
|| Short.class.isAssignableFrom(type)
|| Byte.class.isAssignableFrom(type)
|| Boolean.class.isAssignableFrom(type)
|| Float.class.isAssignableFrom(type)
|| Double.class.isAssignableFrom(type)) {
return parseBasicType(type, value);
} else if (String.class.isAssignableFrom(type)) {
return value;
} else if (java.util.Date.class.isAssignableFrom(type)) {
// If it's a date, use the date parser
return parseDate(value, JOXDateHandler.determineDateFormat());
} else {
return null;
}
}
/** Loads the resources */
void initResources() {
final Class<ControlExample> clazz = ControlExample.class;
if (resourceBundle != null) {
try {
if (images == null) {
images = new Image[imageLocations.length];
for (int i = 0; i < imageLocations.length; ++i) {
InputStream sourceStream = clazz.getResourceAsStream(imageLocations[i]);
ImageData source = new ImageData(sourceStream);
if (imageTypes[i] == SWT.ICON) {
ImageData mask = source.getTransparencyMask();
images[i] = new Image(null, source, mask);
} else {
images[i] = new Image(null, source);
}
try {
sourceStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return;
} catch (Throwable t) {
}
}
String error =
(resourceBundle != null)
? getResourceString("error.CouldNotLoadResources")
: "Unable to load resources"; //$NON-NLS-1$
freeResources();
throw new RuntimeException(error);
}
/**
* Returns compact class host.
*
* @param obj Object to compact.
* @return String.
*/
@Nullable
public static Object compactObject(Object obj) {
if (obj == null) return null;
if (obj instanceof Enum) return obj.toString();
if (obj instanceof String || obj instanceof Boolean || obj instanceof Number) return obj;
if (obj instanceof Collection) {
Collection col = (Collection) obj;
Object[] res = new Object[col.size()];
int i = 0;
for (Object elm : col) res[i++] = compactObject(elm);
return res;
}
if (obj.getClass().isArray()) {
Class<?> arrType = obj.getClass().getComponentType();
if (arrType.isPrimitive()) {
if (obj instanceof boolean[]) return Arrays.toString((boolean[]) obj);
if (obj instanceof byte[]) return Arrays.toString((byte[]) obj);
if (obj instanceof short[]) return Arrays.toString((short[]) obj);
if (obj instanceof int[]) return Arrays.toString((int[]) obj);
if (obj instanceof long[]) return Arrays.toString((long[]) obj);
if (obj instanceof float[]) return Arrays.toString((float[]) obj);
if (obj instanceof double[]) return Arrays.toString((double[]) obj);
}
Object[] arr = (Object[]) obj;
int iMax = arr.length - 1;
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i <= iMax; i++) {
sb.append(compactObject(arr[i]));
if (i != iMax) sb.append(", ");
}
sb.append("]");
return sb.toString();
}
return U.compact(obj.getClass().getName());
}
/**
* Log task mapped.
*
* @param log Logger.
* @param clazz Task class.
* @param nodes Mapped nodes.
*/
public static void logMapped(
@Nullable IgniteLogger log, Class<?> clazz, Collection<ClusterNode> nodes) {
log0(
log,
U.currentTimeMillis(),
String.format("[%s]: MAPPED: %s", clazz.getSimpleName(), U.toShortString(nodes)));
}
public ICFLibAnyObj getObjQualifier(Class qualifyingClass) {
ICFLibAnyObj container = this;
if (qualifyingClass != null) {
while (container != null) {
if (container instanceof ICFSecurityClusterObj) {
break;
} else if (container instanceof ICFSecurityTenantObj) {
break;
} else if (qualifyingClass.isInstance(container)) {
break;
}
container = container.getObjScope();
}
} else {
while (container != null) {
if (container instanceof ICFSecurityClusterObj) {
break;
} else if (container instanceof ICFSecurityTenantObj) {
break;
}
container = container.getObjScope();
}
}
return (container);
}
private void ListValueChanged(
javax.swing.event.ListSelectionEvent evt) { // GEN-FIRST:event_ListValueChanged
// TODO add your handling code here:
// String part=partno.getText();
try {
String sql =
"SELECT TYPE,ITEM_NAME,QUANTITY,MRP FROM MOTORS WHERE ITEM_NAME='"
+ List.getSelectedValue()
+ "'";
Class.forName("com.mysql.jdbc.Driver");
Connection con =
(Connection)
DriverManager.getConnection("jdbc:mysql://localhost:3306/bharatmotors", "root", "");
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);
while (rs.next()) {
partno.setText(rs.getString("TYPE"));
name.setText(rs.getString("ITEM_NAME"));
qty.setText(rs.getString("QUANTITY"));
rate.setText(rs.getString("MRP"));
}
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e.toString());
}
} // GEN-LAST:event_ListValueChanged
/**
* Log finished.
*
* @param log Logger.
* @param clazz Class.
* @param start Start time.
*/
public static void logFinish(@Nullable IgniteLogger log, Class<?> clazz, long start) {
final long end = U.currentTimeMillis();
log0(
log,
end,
String.format(
"[%s]: FINISHED, duration: %s", clazz.getSimpleName(), formatDuration(end - start)));
}
private static final Record getTypedObject(int type) {
if (type < 0 || type > knownRecords.length) return unknownRecord.getObject();
if (knownRecords[type] != null) return knownRecords[type];
/* Construct the class name by putting the type before "Record". */
String s =
Record.class.getPackage().getName() + "." + Type.string(type).replace('-', '_') + "Record";
try {
Class c = Class.forName(s);
Constructor m = c.getDeclaredConstructor(emptyClassArray);
knownRecords[type] = (Record) m.newInstance(emptyObjectArray);
} catch (ClassNotFoundException e) {
/* This is normal; do nothing */
} catch (Exception e) {
if (Options.check("verbose")) System.err.println(e);
}
if (knownRecords[type] == null) knownRecords[type] = unknownRecord.getObject();
return knownRecords[type];
}
/**
* Log message.
*
* @param log Logger.
* @param msg Message to log.
* @param clazz class.
* @param start start time.
* @return Time when message was logged.
*/
public static long log(@Nullable IgniteLogger log, String msg, Class<?> clazz, long start) {
final long end = U.currentTimeMillis();
log0(
log,
end,
String.format(
"[%s]: %s, duration: %s", clazz.getSimpleName(), msg, formatDuration(end - start)));
return end;
}
public static Field makeAccessible(Class<?> target, String fieldName) {
try {
final Field field = target.getDeclaredField(fieldName);
return (Field)
AccessController.doPrivileged(
new PrivilegedExceptionAction<Object>() {
public Object run() throws IllegalAccessException, InvocationTargetException {
if (!field.isAccessible()) field.setAccessible(true);
return field;
}
});
} catch (NoSuchFieldException | PrivilegedActionException e) {
System.out.print("");
} // keep quiet IError.printStackTrace(e); }
return null;
}
private void jButton4ActionPerformed(
java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jButton4ActionPerformed
// TODO add your handling code here:
String wash = chrg.getText();
cname = custname.getText();
addr1 = addr.getText();
total.setText(String.valueOf(tamount));
String a = lcharge.getText();
String b = total.getText();
String j = la.getText();
String c = con.getText();
int d = Integer.parseInt(b);
int e = Integer.parseInt(a);
int g = Integer.parseInt(wash);
int h = Integer.parseInt(c);
int i = Integer.parseInt(j);
int f = d + e + g + h + i;
toamnt.setText(String.valueOf(f));
String sql =
"insert into bill(Bill_No,Bill_Date,Cust_Name,Cust_Addr,P_Details,Amount) values('"
+ no1
+ "','"
+ bill1
+ "','"
+ cname
+ "','"
+ addr1
+ "','"
+ pd
+ "','"
+ toamnt
+ "')";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con =
(Connection)
DriverManager.getConnection("jdbc:mysql://localhost:3306/bharatmotors", "root", "");
Statement stmt = con.createStatement();
stmt.executeUpdate(sql);
} catch (Exception e2) {
JOptionPane.showMessageDialog(this, e2.getMessage());
}
} // GEN-LAST:event_jButton4ActionPerformed
public void FillList() {
try {
String sql1 = "select * from motors";
Class.forName("com.mysql.jdbc.Driver");
Connection con =
(Connection)
DriverManager.getConnection("jdbc:mysql://localhost:3306/bharatmotors", "root", "");
Statement stmt = con.createStatement();
ResultSet rs1 = stmt.executeQuery(sql1);
DefaultListModel DLM = new DefaultListModel();
while (rs1.next()) {
DLM.addElement(rs1.getString(3));
// DLM.addElement(rs1.getString(2));
}
List.setModel(DLM);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "e.getString()");
}
}
/**
* Reads an string into a basic type
*
* @param type The type of the string to read
* @param str The string containing the value
* @return The parsed value of the string
*/
public static Object parseBasicType(Class type, String str) {
// Parse the text based on the property type
if (type.equals(Integer.TYPE) || Integer.class.isAssignableFrom(type)) {
return new Integer(str);
} else if (type.equals(Long.TYPE) || Long.class.isAssignableFrom(type)) {
return new Long(str);
} else if (type.equals(Short.TYPE) || Short.class.isAssignableFrom(type)) {
return new Short(str);
} else if (type.equals(Byte.TYPE) || Byte.class.isAssignableFrom(type)) {
return new Byte(str);
} else if (type.equals(Boolean.TYPE) || Boolean.class.isAssignableFrom(type)) {
return new Boolean(str);
} else if (type.equals(Float.TYPE) || Float.class.isAssignableFrom(type)) {
return new Float(str);
} else if (type.equals(Double.TYPE) || Double.class.isAssignableFrom(type)) {
return new Double(str);
}
return null;
}
/**
* ** Returns an I18N.Text instance used for lazy localization ** @param clazz The class from
* which the package is derived ** @param key The localization key ** @param dft The default
* localized text ** @return An I18N.Text instance used for lazy localization
*/
public static I18N.Text getString(Class clazz, String key, String dft) {
// i18n 'key' is separately specified
String pkg = (clazz != null) ? clazz.getPackage().getName() : null;
return I18N.parseText(pkg, key, dft);
}
public Text(Class clazz, String key, String dft) {
this.pkg = (clazz != null) ? clazz.getPackage().getName() : null;
this.key = (key != null) ? key : "";
this.dft = (dft != null) ? dft : "";
// Print.logInfo("I18N Text: key=" + key + " default=" + dft);
}
public MLogger getMLogger(Class cl) {
return getLogger(cl.getName());
}
/**
* Takes a vector full of property lists and generates a report.
*
* @param args Command line arguments. args[0] should be the config filename.
*/
public static void main(String[] args) {
// Load the database properties from properties file
Properties properties = new Properties();
// Load config file
String configFile = null;
if (args.length > 0) configFile = args[0];
try {
if (configFile == null) {
System.out.println("Database config file not set.");
return;
} else properties.load(new FileInputStream(configFile));
} catch (IOException e) {
System.out.println("Error opening config file.");
}
String url = properties.getProperty("databaseUrl");
String username = properties.getProperty("username");
String password = properties.getProperty("password");
String dir = System.getProperty("user.dir"); // Current working directory
Connection con = null;
// Try to open file containing javac output
String output = "";
try {
BufferedReader outputReader = new BufferedReader(new FileReader(dir + "/CompileOut.txt"));
while (outputReader.ready()) output += outputReader.readLine() + '\n';
// Close file
outputReader.close();
} catch (FileNotFoundException e) {
System.out.println("Error opening compilation output file.");
return;
} catch (IOException e) {
System.out.println("I/O Exception Occured.");
return;
}
boolean hasDriver = false;
// Create class for the driver
try {
Class.forName("com.mysql.jdbc.Driver");
hasDriver = true;
} catch (Exception e) {
System.out.println("Failed to load MySQL JDBC driver class.");
}
// Create connection to database if the driver was found
if (hasDriver) {
try {
con = DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
System.out.println("Couldn't get connection!");
}
}
// Check that a connection was made
if (con != null) {
long userEventId = -1;
// Store results from the report into the database
try {
BufferedReader rd =
new BufferedReader(
new FileReader(dir + "/userId.txt")); // Read userId.txt to get userId
String userId = rd.readLine(); // Store userId from text file
rd.close();
// Insert the report into the table and get the auto_increment id for it
Statement stmt = con.createStatement();
stmt.executeUpdate("INSERT INTO userEvents (userId) VALUES ('" + userId + "')");
ResultSet result = stmt.getGeneratedKeys();
result.next();
userEventId = result.getLong(1);
// Close the statement
stmt.close();
// Prepare statement for adding the compilation error to the userEvent
PreparedStatement compErrorPrepStmt =
con.prepareStatement(
"INSERT INTO userEventCompilationErrors(userEventId, output) VALUES (?, ?)");
// Insert userEventId and docletId into the database
compErrorPrepStmt.setLong(1, userEventId);
compErrorPrepStmt.setString(2, output);
compErrorPrepStmt.executeUpdate();
// Close the prepare statements
compErrorPrepStmt.close();
} catch (Exception e) {
System.out.println("Exception Occurred");
System.out.println(e);
}
// Store the java files for the report
try {
// Prepare statement for storing files
PreparedStatement filePrepStmt =
con.prepareStatement(
"INSERT INTO files(userEventId, filename, contents) VALUES ("
+ userEventId
+ ", ?, ?)");
// Get the list of files from source.txt
BufferedReader rd =
new BufferedReader(
new FileReader(dir + "/source.txt")); // Read userId.txt to get userId
while (rd.ready()) {
String filename = rd.readLine(); // Store userId from text file
// Remove the "src/" from the beginning to get the real file name
String realname = filename.substring(4);
filePrepStmt.setString(1, realname);
// Read in the contents of the files
String contents = "";
File javaFile = new File(dir + "/" + filename);
int length = (int) javaFile.length();
// Add parameter for file contents to the prepared statement and execute it
filePrepStmt.setCharacterStream(2, new BufferedReader(new FileReader(javaFile)), length);
filePrepStmt.executeUpdate();
}
rd.close();
} catch (IOException e) {
System.err.println("I/O Exception Occured.");
} catch (SQLException e) {
System.err.println("SQL Exception Occured.");
}
}
}
public static Object element(Object arg, ExecutionContext context)
throws FunctionDomainException, TypeMismatchException {
if (arg == null || arg == QueryService.UNDEFINED) return QueryService.UNDEFINED;
if (arg instanceof Collection) {
Collection c = (Collection) arg;
// for remote distinct queries, the result of sub query could contain a
// mix of String and PdxString which could be duplicates, so convert all
// PdxStrings to String
if (context.isDistinct() && ((DefaultQuery) context.getQuery()).isRemoteQuery()) {
Set tempResults = new HashSet();
for (Object o : c) {
if (o instanceof PdxString) {
o = ((PdxString) o).toString();
}
tempResults.add(o);
}
c.clear();
c.addAll(tempResults);
tempResults = null;
}
checkSingleton(c.size());
return c.iterator().next();
}
// not a Collection, must be an array
Class clazz = arg.getClass();
if (!clazz.isArray())
throw new TypeMismatchException(
LocalizedStrings.Functions_THE_ELEMENT_FUNCTION_CANNOT_BE_APPLIED_TO_AN_OBJECT_OF_TYPE_0
.toLocalizedString(clazz.getName()));
// handle arrays
if (arg instanceof Object[]) {
Object[] a = (Object[]) arg;
if (((DefaultQuery) context.getQuery()).isRemoteQuery() && context.isDistinct()) {
for (int i = 0; i < a.length; i++) {
if (a[i] instanceof PdxString) {
a[i] = ((PdxString) a[i]).toString();
}
}
}
checkSingleton(a.length);
return a[0];
}
if (arg instanceof int[]) {
int[] a = (int[]) arg;
checkSingleton(a.length);
return Integer.valueOf(a[0]);
}
if (arg instanceof long[]) {
long[] a = (long[]) arg;
checkSingleton(a.length);
return Long.valueOf(a[0]);
}
if (arg instanceof boolean[]) {
boolean[] a = (boolean[]) arg;
checkSingleton(a.length);
return Boolean.valueOf(a[0]);
}
if (arg instanceof byte[]) {
byte[] a = (byte[]) arg;
checkSingleton(a.length);
return Byte.valueOf(a[0]);
}
if (arg instanceof char[]) {
char[] a = (char[]) arg;
checkSingleton(a.length);
return new Character(a[0]);
}
if (arg instanceof double[]) {
double[] a = (double[]) arg;
checkSingleton(a.length);
return Double.valueOf(a[0]);
}
if (arg instanceof float[]) {
float[] a = (float[]) arg;
checkSingleton(a.length);
return new Float(a[0]);
}
if (arg instanceof short[]) {
short[] a = (short[]) arg;
checkSingleton(a.length);
return new Short(a[0]);
}
// did I miss something?
throw new TypeMismatchException(
LocalizedStrings.Functions_THE_ELEMENT_FUNCTION_CANNOT_BE_APPLIED_TO_AN_OBJECT_OF_TYPE_0
.toLocalizedString(clazz.getName()));
}
// Information needed to get a single file:
// BASE_PATH, FILE_ID, TIMESTAMP_START, TIMESTAMP_STOP, SOURCE, FILESYSTEM
private static Vector<Path> getFile(
FileSystem fs, Hashtable<String, String> config, dbutil db_util) throws Exception {
Long latestVersion = latestVersion(config, db_util);
try {
config.put("timestamp_start", config.get("timestamp_start"));
config.put("timestamp_real", latestVersion.toString());
config.put("timestamp_stop", latestVersion.toString());
} catch (Exception E) {
logger.error("Tryign to get file that is impossible to generate: " + getFullPath(config));
return null;
}
if (Integer.parseInt(config.get("timestamp_start"))
> Integer.parseInt(config.get("timestamp_stop"))) {
return null;
}
logger.debug(
"Getting DB for timestamp "
+ config.get("timestamp_start")
+ " to "
+ config.get("timestamp_stop"));
String final_result = getFullPath(config);
String temp_path_base =
config.get("local_temp_path")
+ "_"
+ config.get("task_id")
+ "_"
+ config.get("run_id")
+ "/";
Path newPath = new Path(final_result + "*");
Vector<Path> ret_path = new Vector<Path>();
String lockName = lock(final_result.replaceAll("/", "_"));
if (fs.globStatus(newPath).length != 0) {
ret_path.add(newPath);
unlock(lockName);
config.put("full_file_name", final_result);
return ret_path;
} else {
if (!config.get("source").equals("local")) {
config.put("temp_path_base", temp_path_base);
config.put("timestamp_start", config.get("timestamp_start"));
config.put("timestamp_real", latestVersion.toString());
config.put("timestamp_stop", latestVersion.toString());
Class<?> sourceClass =
Class.forName("org.gestore.plugin.source." + config.get("source") + "Source");
Method process_data = sourceClass.getMethod("process", Hashtable.class, FileSystem.class);
Object processor = sourceClass.newInstance();
Object retVal;
try {
retVal = process_data.invoke(processor, config, fs);
} catch (InvocationTargetException E) {
Throwable exception = E.getTargetException();
logger.error("Unable to call method in child class: " + exception.toString());
exception.printStackTrace(System.out);
unlock(lockName);
return null;
}
FileStatus[] files = (FileStatus[]) retVal;
if (files == null) {
logger.error("Error getting files, no files returned");
return null;
}
for (FileStatus file : files) {
Path cur_file = file.getPath();
Path cur_local_path = new Path(temp_path_base + config.get("file_id"));
String suffix = getSuffix(config.get("file_id"), cur_file.getName());
cur_local_path = cur_local_path.suffix(suffix);
Path res_path = new Path(new String(final_result + suffix));
logger.debug("Moving file" + cur_file.toString() + " to " + res_path.toString());
if (config.get("copy").equals("true")) {
fs.moveFromLocalFile(cur_file, res_path);
} else {
fs.rename(cur_file, res_path);
}
}
config.put("full_file_name", final_result);
}
}
unlock(lockName);
return ret_path;
}
/**
* ** Returns an I18N instance based on the specified package name and Locale ** @param pkgClz The
* class from which the class package is derived ** @param loc The Locale resource from with the
* localized text is loaded
*/
public static I18N getI18N(Class pkgClz, Locale loc) {
return I18N.getI18N(pkgClz.getPackage().getName(), loc);
}
/**
* Log start.
*
* @param log Logger.
* @param clazz Class.
* @param start Start time.
*/
public static void logStart(@Nullable IgniteLogger log, Class<?> clazz, long start) {
log0(log, start, "[" + clazz.getSimpleName() + "]: STARTED");
}
/**
* Examines a property's type to see which method should be used to parse the property's value.
*
* @param desc The description of the property
* @param element The XML element containing the property value
* @return The value stored in the element
* @throws IOException If there is an error reading the document
*/
public Object getObjectValue(PropertyDescriptor desc, Element element) throws IOException {
// Find out what kind of property it is
Class type = desc.getPropertyType();
// If it's an array, get the base type
if (type.isArray()) {
type = type.getComponentType();
}
// For native types, object wrappers for natives, and strings, use the
// basic parse routine
if (type.equals(Integer.TYPE)
|| type.equals(Long.TYPE)
|| type.equals(Short.TYPE)
|| type.equals(Byte.TYPE)
|| type.equals(Boolean.TYPE)
|| type.equals(Float.TYPE)
|| type.equals(Double.TYPE)
|| Integer.class.isAssignableFrom(type)
|| Long.class.isAssignableFrom(type)
|| Short.class.isAssignableFrom(type)
|| Byte.class.isAssignableFrom(type)
|| Boolean.class.isAssignableFrom(type)
|| Float.class.isAssignableFrom(type)
|| Double.class.isAssignableFrom(type)
|| String.class.isAssignableFrom(type)) {
return readBasicType(type, element);
} else if (java.util.Date.class.isAssignableFrom(type)) {
// If it's a date, use the date parser
return readDate(element);
} else {
try {
// If it's an object, create a new instance of the object (it should
// be a bean, or there will be trouble)
Object newOb = type.newInstance();
// Copy the XML element into the bean
readObject(newOb, element);
return newOb;
} catch (InstantiationException exc) {
throw new IOException(
"Error creating object for " + desc.getName() + ": " + exc.toString());
} catch (IllegalAccessException exc) {
throw new IOException(
"Error creating object for " + desc.getName() + ": " + exc.toString());
}
}
}
