home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 March / PCWorld_2001-03_cd.bin / Software / Komercni / VAgeJava / ivj35 / setup / JSP.Cab / F27263_LeapYearBeanBeanInfo.java < prev    next >
Encoding:
Java Source  |  2000-08-10  |  17.1 KB  |  456 lines
  1. package com.ibm.ivj.wte.samples.leapyear;
  2.  
  3. // Licensed Material - Property of IBM 
  4. // (C) Copyright IBM Corp. 2000 - All Rights Reserved 
  5. // 
  6. // DISCLAIMER: 
  7. // The following [enclosed] code is sample code created by IBM 
  8. // Corporation.  This sample code is not part of any standard IBM product 
  9. // and is provided to you solely for the purpose of assisting you in the 
  10. // development of your applications.  The code is provided 'AS IS', 
  11. // without warranty or condition of any kind.  IBM shall not be liable for any damages 
  12. // arising out of your use of the sample code, even if IBM has been 
  13. // advised of the possibility of such damages.
  14.  
  15. /**
  16.  * The bean information class for com.ibm.ivj.wte.samples.leapyear.LeapYearBean.
  17.  */
  18. public class LeapYearBeanBeanInfo extends java.beans.SimpleBeanInfo {
  19. private static final String copyright = 
  20.     "(c) Copyright IBM Corporation 2000.";
  21.  
  22. /**
  23.  * Gets the findLeapYears() method descriptor.
  24.  * @return java.beans.MethodDescriptor
  25.  */
  26. public java.beans.MethodDescriptor findLeapYearsMethodDescriptor() {
  27.     java.beans.MethodDescriptor aDescriptor = null;
  28.     try {
  29.         /* Create and return the findLeapYears() method descriptor. */
  30.         java.lang.reflect.Method aMethod = null;
  31.         try {
  32.             /* Attempt to find the method using getMethod with parameter types. */
  33.             java.lang.Class aParameterTypes[] = {};
  34.             aMethod = getBeanClass().getMethod("findLeapYears", aParameterTypes);
  35.         } catch (Throwable exception) {
  36.             /* Since getMethod failed, call findMethod. */
  37.             handleException(exception);
  38.             aMethod = findMethod(getBeanClass(), "findLeapYears", 0);
  39.         };
  40.         try {
  41.             /* Try creating the method descriptor with parameter descriptors. */
  42.             java.beans.ParameterDescriptor aParameterDescriptors[] = {};
  43.             aDescriptor = new java.beans.MethodDescriptor(aMethod, aParameterDescriptors);
  44.         } catch (Throwable exception) {
  45.             /* Try creating the method descriptor without parameter descriptors. */
  46.             handleException(exception);
  47.             aDescriptor = new java.beans.MethodDescriptor(aMethod);
  48.         };
  49.         /* aDescriptor.setDisplayName("findLeapYears()"); */
  50.         /* aDescriptor.setShortDescription("findLeapYears()"); */
  51.         /* aDescriptor.setExpert(false); */
  52.         /* aDescriptor.setHidden(false); */
  53.         /* aDescriptor.setValue("preferred", new Boolean(false)); */
  54.     } catch (Throwable exception) {
  55.         handleException(exception);
  56.     };
  57.     return aDescriptor;
  58. }
  59. /**
  60.  * Find the method by comparing (name & parameter size) against the methods in the class.
  61.  * @return java.lang.reflect.Method
  62.  * @param aClass java.lang.Class
  63.  * @param methodName java.lang.String
  64.  * @param parameterCount int
  65.  */
  66. public static java.lang.reflect.Method findMethod(java.lang.Class aClass, java.lang.String methodName, int parameterCount) {
  67.     try {
  68.         /* Since this method attempts to find a method by getting all methods from the class,
  69.     this method should only be called if getMethod cannot find the method. */
  70.         java.lang.reflect.Method methods[] = aClass.getMethods();
  71.         for (int index = 0; index < methods.length; index++){
  72.             java.lang.reflect.Method method = methods[index];
  73.             if ((method.getParameterTypes().length == parameterCount) && (method.getName().equals(methodName))) {
  74.                 return method;
  75.             }
  76.         }
  77.     } catch (java.lang.Throwable exception) {
  78.         return null;
  79.     }
  80.     return null;
  81. }
  82. /**
  83.  * Returns the BeanInfo of the superclass of this bean to inherit its features.
  84.  * @return java.beans.BeanInfo[]
  85.  */
  86. public java.beans.BeanInfo[] getAdditionalBeanInfo() {
  87.     java.lang.Class superClass;
  88.     java.beans.BeanInfo superBeanInfo = null;
  89.  
  90.     try {
  91.         superClass = getBeanDescriptor().getBeanClass().getSuperclass();
  92.     } catch (java.lang.Throwable exception) {
  93.         return null;
  94.     }
  95.  
  96.     try {
  97.         superBeanInfo = java.beans.Introspector.getBeanInfo(superClass);
  98.     } catch (java.beans.IntrospectionException ie) {}
  99.  
  100.     if (superBeanInfo != null) {
  101.         java.beans.BeanInfo[] ret = new java.beans.BeanInfo[1];
  102.         ret[0] = superBeanInfo;
  103.         return ret;
  104.     }
  105.     return null;
  106. }
  107. /**
  108.  * Gets the bean class.
  109.  * @return java.lang.Class
  110.  */
  111. public static java.lang.Class getBeanClass() {
  112.     return com.ibm.ivj.wte.samples.leapyear.LeapYearBean.class;
  113. }
  114. /**
  115.  * Gets the bean class name.
  116.  * @return java.lang.String
  117.  */
  118. public static java.lang.String getBeanClassName() {
  119.     return "com.ibm.ivj.wte.samples.leapyear.LeapYearBean";
  120. }
  121. public java.beans.BeanDescriptor getBeanDescriptor() {
  122.     java.beans.BeanDescriptor aDescriptor = null;
  123.     try {
  124.         /* Create and return the LeapYearBeanBeanInfo bean descriptor. */
  125.         aDescriptor = new java.beans.BeanDescriptor(com.ibm.ivj.wte.samples.leapyear.LeapYearBean.class);
  126.         /* aDescriptor.setExpert(false); */
  127.         /* aDescriptor.setHidden(false); */
  128.         /* aDescriptor.setValue("hidden-state", Boolean.FALSE); */
  129.     } catch (Throwable exception) {
  130.     };
  131.     return aDescriptor;
  132. }
  133. /**
  134.  * Return the event set descriptors for this bean.
  135.  * @return java.beans.EventSetDescriptor[]
  136.  */
  137. public java.beans.EventSetDescriptor[] getEventSetDescriptors() {
  138.     try {
  139.         java.beans.EventSetDescriptor aDescriptorList[] = {};
  140.         return aDescriptorList;
  141.     } catch (Throwable exception) {
  142.         handleException(exception);
  143.     };
  144.     return null;
  145. }
  146. /**
  147.  * Gets the getLeapYears(int) method descriptor.
  148.  * @return java.beans.MethodDescriptor
  149.  */
  150. public java.beans.MethodDescriptor getLeapYears_intMethodDescriptor() {
  151.     java.beans.MethodDescriptor aDescriptor = null;
  152.     try {
  153.         /* Create and return the getLeapYears(int) method descriptor. */
  154.         java.lang.reflect.Method aMethod = null;
  155.         try {
  156.             /* Attempt to find the method using getMethod with parameter types. */
  157.             java.lang.Class aParameterTypes[] = {
  158.                 int.class
  159.             };
  160.             aMethod = getBeanClass().getMethod("getLeapYears", aParameterTypes);
  161.         } catch (Throwable exception) {
  162.             /* Since getMethod failed, call findMethod. */
  163.             handleException(exception);
  164.             aMethod = findMethod(getBeanClass(), "getLeapYears", 1);
  165.         };
  166.         try {
  167.             /* Try creating the method descriptor with parameter descriptors. */
  168.             java.beans.ParameterDescriptor aParameterDescriptor1 = new java.beans.ParameterDescriptor();
  169.             aParameterDescriptor1.setName("arg1");
  170.             aParameterDescriptor1.setDisplayName("index");
  171.             java.beans.ParameterDescriptor aParameterDescriptors[] = {
  172.                 aParameterDescriptor1
  173.             };
  174.             aDescriptor = new java.beans.MethodDescriptor(aMethod, aParameterDescriptors);
  175.         } catch (Throwable exception) {
  176.             /* Try creating the method descriptor without parameter descriptors. */
  177.             handleException(exception);
  178.             aDescriptor = new java.beans.MethodDescriptor(aMethod);
  179.         };
  180.         /* aDescriptor.setDisplayName("getLeapYears(int)"); */
  181.         /* aDescriptor.setShortDescription("getLeapYears(int)"); */
  182.         /* aDescriptor.setExpert(false); */
  183.         /* aDescriptor.setHidden(false); */
  184.         /* aDescriptor.setValue("preferred", new Boolean(false)); */
  185.     } catch (Throwable exception) {
  186.         handleException(exception);
  187.     };
  188.     return aDescriptor;
  189. }
  190. /**
  191.  * Return the method descriptors for this bean.
  192.  * @return java.beans.MethodDescriptor[]
  193.  */
  194. public java.beans.MethodDescriptor[] getMethodDescriptors() {
  195.     try {
  196.         java.beans.MethodDescriptor aDescriptorList[] = {
  197.             findLeapYearsMethodDescriptor()
  198.             ,getLeapYears_intMethodDescriptor()
  199.             ,isLeapYear_intMethodDescriptor()
  200.             ,setLeapYears_int_intMethodDescriptor()
  201.         };
  202.         return aDescriptorList;
  203.     } catch (Throwable exception) {
  204.         handleException(exception);
  205.     };
  206.     return null;
  207. }
  208. /**
  209.  * Return the property descriptors for this bean.
  210.  * @return java.beans.PropertyDescriptor[]
  211.  */
  212. public java.beans.PropertyDescriptor[] getPropertyDescriptors() {
  213.     try {
  214.         java.beans.PropertyDescriptor aDescriptorList[] = {
  215.             startYearPropertyDescriptor()
  216.         };
  217.         return aDescriptorList;
  218.     } catch (Throwable exception) {
  219.         handleException(exception);
  220.     };
  221.     return null;
  222. }
  223. /**
  224.  * Called whenever the bean information class throws an exception.
  225.  * @param exception java.lang.Throwable
  226.  */
  227. private void handleException(java.lang.Throwable exception) {
  228.  
  229.     /* Uncomment the following lines to print uncaught exceptions to stdout */
  230.     // System.out.println("--------- UNCAUGHT EXCEPTION ---------");
  231.     // exception.printStackTrace(System.out);
  232. }
  233. /**
  234.  * Gets the isLeapYear(int) method descriptor.
  235.  * @return java.beans.MethodDescriptor
  236.  */
  237. public java.beans.MethodDescriptor isLeapYear_intMethodDescriptor() {
  238.     java.beans.MethodDescriptor aDescriptor = null;
  239.     try {
  240.         /* Create and return the isLeapYear(int) method descriptor. */
  241.         java.lang.reflect.Method aMethod = null;
  242.         try {
  243.             /* Attempt to find the method using getMethod with parameter types. */
  244.             java.lang.Class aParameterTypes[] = {
  245.                 int.class
  246.             };
  247.             aMethod = getBeanClass().getMethod("isLeapYear", aParameterTypes);
  248.         } catch (Throwable exception) {
  249.             /* Since getMethod failed, call findMethod. */
  250.             handleException(exception);
  251.             aMethod = findMethod(getBeanClass(), "isLeapYear", 1);
  252.         };
  253.         try {
  254.             /* Try creating the method descriptor with parameter descriptors. */
  255.             java.beans.ParameterDescriptor aParameterDescriptor1 = new java.beans.ParameterDescriptor();
  256.             aParameterDescriptor1.setName("arg1");
  257.             aParameterDescriptor1.setDisplayName("argYear");
  258.             java.beans.ParameterDescriptor aParameterDescriptors[] = {
  259.                 aParameterDescriptor1
  260.             };
  261.             aDescriptor = new java.beans.MethodDescriptor(aMethod, aParameterDescriptors);
  262.         } catch (Throwable exception) {
  263.             /* Try creating the method descriptor without parameter descriptors. */
  264.             handleException(exception);
  265.             aDescriptor = new java.beans.MethodDescriptor(aMethod);
  266.         };
  267.         /* aDescriptor.setDisplayName("isLeapYear(int)"); */
  268.         /* aDescriptor.setShortDescription("isLeapYear(int)"); */
  269.         /* aDescriptor.setExpert(false); */
  270.         /* aDescriptor.setHidden(false); */
  271.         /* aDescriptor.setValue("preferred", new Boolean(false)); */
  272.     } catch (Throwable exception) {
  273.         handleException(exception);
  274.     };
  275.     return aDescriptor;
  276. }
  277. /**
  278.  * Gets the leapYears property descriptor.
  279.  * @return java.beans.IndexedPropertyDescriptor
  280.  */
  281. public java.beans.IndexedPropertyDescriptor leapYearsPropertyDescriptor() {
  282.     java.beans.IndexedPropertyDescriptor aDescriptor = null;
  283.     try {
  284.         try {
  285.             /* Using methods via getMethod is the faster way to create the leapYears property descriptor. */
  286.             java.lang.reflect.Method aGetMethod = null;
  287.             try {
  288.                 /* Attempt to find the method using getMethod with parameter types. */
  289.                 java.lang.Class aGetMethodParameterTypes[] = {};
  290.                 aGetMethod = getBeanClass().getMethod("getLeapYears", aGetMethodParameterTypes);
  291.             } catch (Throwable exception) {
  292.                 /* Since getMethod failed, call findMethod. */
  293.                 handleException(exception);
  294.                 aGetMethod = findMethod(getBeanClass(), "getLeapYears", 0);
  295.             };
  296.             java.lang.reflect.Method aSetMethod = null;
  297.             try {
  298.                 /* Attempt to find the method using getMethod with parameter types. */
  299.                 java.lang.Class aSetMethodParameterTypes[] = {
  300.                     int[].class
  301.                 };
  302.                 aSetMethod = getBeanClass().getMethod("setLeapYears", aSetMethodParameterTypes);
  303.             } catch (Throwable exception) {
  304.                 /* Since getMethod failed, call findMethod. */
  305.                 handleException(exception);
  306.                 aSetMethod = findMethod(getBeanClass(), "setLeapYears", 1);
  307.             };
  308.             java.lang.reflect.Method aGetIndexedMethod = null;
  309.             try {
  310.                 /* Attempt to find the method using getMethod with parameter types. */
  311.                 java.lang.Class aGetIndexedMethodParameterTypes[] = {
  312.                     int.class
  313.                 };
  314.                 aGetIndexedMethod = getBeanClass().getMethod("getLeapYears", aGetIndexedMethodParameterTypes);
  315.             } catch (Throwable exception) {
  316.                 /* Since getMethod failed, call findMethod. */
  317.                 handleException(exception);
  318.                 aGetIndexedMethod = findMethod(getBeanClass(), "getLeapYears", 1);
  319.             };
  320.             java.lang.reflect.Method aSetIndexedMethod = null;
  321.             try {
  322.                 /* Attempt to find the method using getMethod with parameter types. */
  323.                 java.lang.Class aSetIndexedMethodParameterTypes[] = {
  324.                     int.class,
  325.                     int.class
  326.                 };
  327.                 aSetIndexedMethod = getBeanClass().getMethod("setLeapYears", aSetIndexedMethodParameterTypes);
  328.             } catch (Throwable exception) {
  329.                 /* Since getMethod failed, call findMethod. */
  330.                 handleException(exception);
  331.                 aSetIndexedMethod = findMethod(getBeanClass(), "setLeapYears", 2);
  332.             };
  333.             aDescriptor = new java.beans.IndexedPropertyDescriptor("leapYears"
  334.             , aGetMethod, aSetMethod, aGetIndexedMethod, aSetIndexedMethod);
  335.         } catch (Throwable exception) {
  336.             /* Since we failed using methods, try creating a default property descriptor. */
  337.             handleException(exception);
  338.             aDescriptor = new java.beans.IndexedPropertyDescriptor("leapYears"
  339.             , getBeanClass());
  340.         };
  341.         /* aDescriptor.setBound(false); */
  342.         /* aDescriptor.setConstrained(false); */
  343.         /* aDescriptor.setDisplayName("leapYears"); */
  344.         /* aDescriptor.setShortDescription("leapYears"); */
  345.         /* aDescriptor.setExpert(false); */
  346.         /* aDescriptor.setHidden(false); */
  347.         /* aDescriptor.setValue("preferred", new Boolean(false)); */
  348.         /* aDescriptor.setValue("ivjDesignTimeProperty", new Boolean(true)); */
  349.     } catch (Throwable exception) {
  350.         handleException(exception);
  351.     };
  352.     return aDescriptor;
  353. }
  354. /**
  355.  * Gets the setLeapYears(int, int) method descriptor.
  356.  * @return java.beans.MethodDescriptor
  357.  */
  358. public java.beans.MethodDescriptor setLeapYears_int_intMethodDescriptor() {
  359.     java.beans.MethodDescriptor aDescriptor = null;
  360.     try {
  361.         /* Create and return the setLeapYears(int, int) method descriptor. */
  362.         java.lang.reflect.Method aMethod = null;
  363.         try {
  364.             /* Attempt to find the method using getMethod with parameter types. */
  365.             java.lang.Class aParameterTypes[] = {
  366.                 int.class,
  367.                 int.class
  368.             };
  369.             aMethod = getBeanClass().getMethod("setLeapYears", aParameterTypes);
  370.         } catch (Throwable exception) {
  371.             /* Since getMethod failed, call findMethod. */
  372.             handleException(exception);
  373.             aMethod = findMethod(getBeanClass(), "setLeapYears", 2);
  374.         };
  375.         try {
  376.             /* Try creating the method descriptor with parameter descriptors. */
  377.             java.beans.ParameterDescriptor aParameterDescriptor1 = new java.beans.ParameterDescriptor();
  378.             aParameterDescriptor1.setName("arg1");
  379.             aParameterDescriptor1.setDisplayName("index");
  380.             java.beans.ParameterDescriptor aParameterDescriptor2 = new java.beans.ParameterDescriptor();
  381.             aParameterDescriptor2.setName("arg2");
  382.             aParameterDescriptor2.setDisplayName("leapYears");
  383.             java.beans.ParameterDescriptor aParameterDescriptors[] = {
  384.                 aParameterDescriptor1,
  385.                 aParameterDescriptor2
  386.             };
  387.             aDescriptor = new java.beans.MethodDescriptor(aMethod, aParameterDescriptors);
  388.         } catch (Throwable exception) {
  389.             /* Try creating the method descriptor without parameter descriptors. */
  390.             handleException(exception);
  391.             aDescriptor = new java.beans.MethodDescriptor(aMethod);
  392.         };
  393.         /* aDescriptor.setDisplayName("setLeapYears(int, int)"); */
  394.         /* aDescriptor.setShortDescription("setLeapYears(int, int)"); */
  395.         /* aDescriptor.setExpert(false); */
  396.         /* aDescriptor.setHidden(false); */
  397.         /* aDescriptor.setValue("preferred", new Boolean(false)); */
  398.     } catch (Throwable exception) {
  399.         handleException(exception);
  400.     };
  401.     return aDescriptor;
  402. }
  403. /**
  404.  * Gets the startYear property descriptor.
  405.  * @return java.beans.PropertyDescriptor
  406.  */
  407. public java.beans.PropertyDescriptor startYearPropertyDescriptor() {
  408.     java.beans.PropertyDescriptor aDescriptor = null;
  409.     try {
  410.         try {
  411.             /* Using methods via getMethod is the faster way to create the startYear property descriptor. */
  412.             java.lang.reflect.Method aGetMethod = null;
  413.             try {
  414.                 /* Attempt to find the method using getMethod with parameter types. */
  415.                 java.lang.Class aGetMethodParameterTypes[] = {};
  416.                 aGetMethod = getBeanClass().getMethod("getStartYear", aGetMethodParameterTypes);
  417.             } catch (Throwable exception) {
  418.                 /* Since getMethod failed, call findMethod. */
  419.                 handleException(exception);
  420.                 aGetMethod = findMethod(getBeanClass(), "getStartYear", 0);
  421.             };
  422.             java.lang.reflect.Method aSetMethod = null;
  423.             try {
  424.                 /* Attempt to find the method using getMethod with parameter types. */
  425.                 java.lang.Class aSetMethodParameterTypes[] = {
  426.                     int.class
  427.                 };
  428.                 aSetMethod = getBeanClass().getMethod("setStartYear", aSetMethodParameterTypes);
  429.             } catch (Throwable exception) {
  430.                 /* Since getMethod failed, call findMethod. */
  431.                 handleException(exception);
  432.                 aSetMethod = findMethod(getBeanClass(), "setStartYear", 1);
  433.             };
  434.             aDescriptor = new java.beans.PropertyDescriptor("startYear"
  435.             , aGetMethod, aSetMethod);
  436.         } catch (Throwable exception) {
  437.             /* Since we failed using methods, try creating a default property descriptor. */
  438.             handleException(exception);
  439.             aDescriptor = new java.beans.PropertyDescriptor("startYear"
  440.             , getBeanClass());
  441.         };
  442.         /* aDescriptor.setBound(false); */
  443.         /* aDescriptor.setConstrained(false); */
  444.         /* aDescriptor.setDisplayName("startYear"); */
  445.         /* aDescriptor.setShortDescription("startYear"); */
  446.         /* aDescriptor.setExpert(false); */
  447.         /* aDescriptor.setHidden(false); */
  448.         /* aDescriptor.setValue("preferred", new Boolean(false)); */
  449.         /* aDescriptor.setValue("ivjDesignTimeProperty", new Boolean(true)); */
  450.     } catch (Throwable exception) {
  451.         handleException(exception);
  452.     };
  453.     return aDescriptor;
  454. }
  455. }
  456.