Beans provides some helper methods that allow the basic operations of Bean-ness.
*
* @author John Keiser
* @since JDK1.1
* @version 1.1.0, 29 Jul 1998
*
*/
public class Beans {
static boolean designTime = false;
static boolean guiAvailable = true;
/**
* Once again, we have a java.beans class with only
* static methods that can be instantiated. When
* will the madness end? :)
*/
public Beans() {
}
/**
* Allows you to instantiate a Bean. This method takes
* a ClassLoader from which to read the Bean and the
* name of the Bean.* * The Bean name should be a dotted name, like a class. * It can represent several things. Beans will search * for the Bean using the name like this:
*
null
* to use the default ClassLoader.
* @param beanName the name of the Bean.
* @return the Bean.
* @XXX
*/
public static Object instantiate(ClassLoader cl, String beanName) throws IOException, ClassNotFoundException {
Object bean;
InputStream serStream;
if(cl == null) {
serStream = ClassLoader.getSystemResourceAsStream(beanName.replace('.','/')+".ser");
} else {
serStream = cl.getResourceAsStream(beanName.replace('.','/')+".ser");
}
if(serStream != null) {
if(cl == null) {
ObjectInputStream ois = new ObjectInputStream(serStream);
bean = ois.readObject();
} else {
ClassLoaderObjectInputStream ois = new ClassLoaderObjectInputStream(serStream, cl);
bean = ois.readObject();
}
} else if(cl == null) {
Class beanClass = Class.forName(beanName);
try {
bean = beanClass.newInstance();
} catch(IllegalAccessException E) {
bean = null;
} catch(InstantiationException E) {
bean = null;
}
} else {
Class beanClass = cl.loadClass(beanName);
try {
bean = beanClass.newInstance();
} catch(IllegalAccessException E) {
bean = null;
} catch(InstantiationException E) {
bean = null;
}
}
if(bean instanceof Applet) {
Applet a = (Applet)bean;
//a.setAppletContext(???);
//a.setStub(???);
if(serStream == null) {
a.init();
}
}
return bean;
}
/**
* Get the Bean as a different class type.
* This should be used instead of casting to get a new
* type view of a Bean, because in the future there may
* be new types of Bean, even Beans spanning multiple
* Objects.
* @param bean the Bean to cast.
* @param newClass the Class to cast it to.
* @return the Bean as a new view, or if the operation
* could not be performed, the Bean itself.
*/
public static Object getInstanceOf(Object bean, Class newClass) {
return bean;
}
/**
* Determine whether the Bean can be cast to a different
* class type.
* This should be used instead of instanceof to determine
* a Bean's castability, because in the future there may
* be new types of Bean, even Beans spanning multiple
* Objects.
* @param bean the Bean to cast.
* @param newClass the Class to cast it to.
* @return whether the Bean can be cast to the class type
* in question.
*/
public static boolean isInstanceOf(Object bean, Class newBeanClass) {
return newBeanClass.isInstance(bean);
}
/**
* Find out whether the GUI is available to use.
* Defaults to true.
* @return whether the GUI is available to use.
*/
public static boolean isGuiAvailable() {
return guiAvailable;
}
/**
* Find out whether it is design time. Design time means
* we are in a RAD tool.
* Defaults to false.
* @return whether it is design time.
*/
public static boolean isDesignTime() {
return designTime;
}
/**
* Set whether the GUI is available to use.
* @param guiAvailable whether the GUI is available to use.
*/
public static void setGuiAvailable(boolean guiAvailable) throws SecurityException {
Beans.guiAvailable = guiAvailable;
}
/**
* Set whether it is design time. Design time means we
* are in a RAD tool.
* @param designTime whether it is design time.
*/
public static void setDesignTime(boolean designTime) throws SecurityException {
Beans.designTime = designTime;
}
}