712 } else {
713 if (spd != null) {
714 spd = new PropertyDescriptor(spd, pd);
715 } else {
716 spd = pd;
717 }
718 }
719 }
720 }
721 }
722
723 // At this stage we should have either PDs or IPDs for the
724 // representative getters and setters. The order at which the
725 // property descriptors are determined represent the
726 // precedence of the property ordering.
727 pd = null; ipd = null;
728
729 if (igpd != null && ispd != null) {
730 // Complete indexed properties set
731 // Merge any classic property descriptors
732 if (gpd != null) {
733 PropertyDescriptor tpd = mergePropertyDescriptor(igpd, gpd);
734 if (tpd instanceof IndexedPropertyDescriptor) {
735 igpd = (IndexedPropertyDescriptor)tpd;
736 }
737 }
738 if (spd != null) {
739 PropertyDescriptor tpd = mergePropertyDescriptor(ispd, spd);
740 if (tpd instanceof IndexedPropertyDescriptor) {
741 ispd = (IndexedPropertyDescriptor)tpd;
742 }
743 }
744 if (igpd == ispd) {
745 pd = igpd;
746 } else {
747 pd = mergePropertyDescriptor(igpd, ispd);
748 }
749 } else if (gpd != null && spd != null) {
750 if (igpd != null) {
751 gpd = mergePropertyWithIndexedProperty(gpd, igpd);
752 }
753 if (ispd != null) {
754 spd = mergePropertyWithIndexedProperty(spd, ispd);
755 }
756 // Complete simple properties set
757 if (gpd == spd) {
758 pd = gpd;
759 } else if (spd instanceof IndexedPropertyDescriptor) {
760 pd = mergePropertyWithIndexedProperty(gpd, (IndexedPropertyDescriptor) spd);
761 } else if (gpd instanceof IndexedPropertyDescriptor) {
762 pd = mergePropertyWithIndexedProperty(spd, (IndexedPropertyDescriptor) gpd);
763 } else {
764 pd = mergePropertyDescriptor(gpd, spd);
765 }
766 } else if (ispd != null) {
767 // indexed setter
831
832 /**
833 * Adds the property descriptor to the indexedproperty descriptor only if the
834 * types are the same.
835 *
836 * The most specific property descriptor will take precedence.
837 */
838 private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,
839 PropertyDescriptor pd) {
840 PropertyDescriptor result = null;
841
842 Class<?> propType = pd.getPropertyType();
843 Class<?> ipropType = ipd.getIndexedPropertyType();
844
845 if (propType.isArray() && propType.getComponentType() == ipropType) {
846 if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
847 result = new IndexedPropertyDescriptor(pd, ipd);
848 } else {
849 result = new IndexedPropertyDescriptor(ipd, pd);
850 }
851 } else {
852 // Cannot merge the pd because of type mismatch
853 // Return the most specific pd
854 if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
855 result = ipd;
856 } else {
857 result = pd;
858 // Try to add methods which may have been lost in the type change
859 // See 4168833
860 Method write = result.getWriteMethod();
861 Method read = result.getReadMethod();
862
863 if (read == null && write != null) {
864 read = findMethod(result.getClass0(),
865 GET_PREFIX + NameGenerator.capitalize(result.getName()), 0);
866 if (read != null) {
867 try {
868 result.setReadMethod(read);
869 } catch (IntrospectionException ex) {
870 // no consequences for failure.
882 // no consequences for failure.
883 }
884 }
885 }
886 }
887 }
888 return result;
889 }
890
891 // Handle regular pd merge
892 private PropertyDescriptor mergePropertyDescriptor(PropertyDescriptor pd1,
893 PropertyDescriptor pd2) {
894 if (pd1.getClass0().isAssignableFrom(pd2.getClass0())) {
895 return new PropertyDescriptor(pd1, pd2);
896 } else {
897 return new PropertyDescriptor(pd2, pd1);
898 }
899 }
900
901 // Handle regular ipd merge
902 private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd1,
903 IndexedPropertyDescriptor ipd2) {
904 if (ipd1.getClass0().isAssignableFrom(ipd2.getClass0())) {
905 return new IndexedPropertyDescriptor(ipd1, ipd2);
906 } else {
907 return new IndexedPropertyDescriptor(ipd2, ipd1);
908 }
909 }
910
911 /**
912 * @return An array of EventSetDescriptors describing the kinds of
913 * events fired by the target bean.
914 */
915 private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
916 if (events == null) {
917 events = new HashMap<>();
918 }
919
920 // Check if the bean has its own BeanInfo that will provide
921 // explicit information.
922 EventSetDescriptor[] explicitEvents = null;
|
712 } else {
713 if (spd != null) {
714 spd = new PropertyDescriptor(spd, pd);
715 } else {
716 spd = pd;
717 }
718 }
719 }
720 }
721 }
722
723 // At this stage we should have either PDs or IPDs for the
724 // representative getters and setters. The order at which the
725 // property descriptors are determined represent the
726 // precedence of the property ordering.
727 pd = null; ipd = null;
728
729 if (igpd != null && ispd != null) {
730 // Complete indexed properties set
731 // Merge any classic property descriptors
732 if ((gpd == spd) || (gpd == null)) {
733 pd = spd;
734 } else if (spd == null) {
735 pd = gpd;
736 } else if (spd instanceof IndexedPropertyDescriptor) {
737 pd = mergePropertyWithIndexedProperty(gpd, (IndexedPropertyDescriptor) spd);
738 } else if (gpd instanceof IndexedPropertyDescriptor) {
739 pd = mergePropertyWithIndexedProperty(spd, (IndexedPropertyDescriptor) gpd);
740 } else {
741 pd = mergePropertyDescriptor(gpd, spd);
742 }
743 if (igpd == ispd) {
744 ipd = igpd;
745 } else {
746 ipd = mergePropertyDescriptor(igpd, ispd);
747 }
748 if (pd == null) {
749 pd = ipd;
750 } else {
751 Class<?> propType = pd.getPropertyType();
752 Class<?> ipropType = ipd.getIndexedPropertyType();
753 if (propType.isArray() && propType.getComponentType() == ipropType) {
754 pd = pd.getClass0().isAssignableFrom(ipd.getClass0())
755 ? new IndexedPropertyDescriptor(pd, ipd)
756 : new IndexedPropertyDescriptor(ipd, pd);
757 } else if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
758 pd = pd.getClass0().isAssignableFrom(ipd.getClass0())
759 ? new PropertyDescriptor(pd, ipd)
760 : new PropertyDescriptor(ipd, pd);
761 } else {
762 pd = ipd;
763 }
764 }
765 } else if (gpd != null && spd != null) {
766 if (igpd != null) {
767 gpd = mergePropertyWithIndexedProperty(gpd, igpd);
768 }
769 if (ispd != null) {
770 spd = mergePropertyWithIndexedProperty(spd, ispd);
771 }
772 // Complete simple properties set
773 if (gpd == spd) {
774 pd = gpd;
775 } else if (spd instanceof IndexedPropertyDescriptor) {
776 pd = mergePropertyWithIndexedProperty(gpd, (IndexedPropertyDescriptor) spd);
777 } else if (gpd instanceof IndexedPropertyDescriptor) {
778 pd = mergePropertyWithIndexedProperty(spd, (IndexedPropertyDescriptor) gpd);
779 } else {
780 pd = mergePropertyDescriptor(gpd, spd);
781 }
782 } else if (ispd != null) {
783 // indexed setter
847
848 /**
849 * Adds the property descriptor to the indexedproperty descriptor only if the
850 * types are the same.
851 *
852 * The most specific property descriptor will take precedence.
853 */
854 private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,
855 PropertyDescriptor pd) {
856 PropertyDescriptor result = null;
857
858 Class<?> propType = pd.getPropertyType();
859 Class<?> ipropType = ipd.getIndexedPropertyType();
860
861 if (propType.isArray() && propType.getComponentType() == ipropType) {
862 if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
863 result = new IndexedPropertyDescriptor(pd, ipd);
864 } else {
865 result = new IndexedPropertyDescriptor(ipd, pd);
866 }
867 } else if ((ipd.getReadMethod() == null) && (ipd.getWriteMethod() == null)) {
868 if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
869 result = new PropertyDescriptor(pd, ipd);
870 } else {
871 result = new PropertyDescriptor(ipd, pd);
872 }
873 } else {
874 // Cannot merge the pd because of type mismatch
875 // Return the most specific pd
876 if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
877 result = ipd;
878 } else {
879 result = pd;
880 // Try to add methods which may have been lost in the type change
881 // See 4168833
882 Method write = result.getWriteMethod();
883 Method read = result.getReadMethod();
884
885 if (read == null && write != null) {
886 read = findMethod(result.getClass0(),
887 GET_PREFIX + NameGenerator.capitalize(result.getName()), 0);
888 if (read != null) {
889 try {
890 result.setReadMethod(read);
891 } catch (IntrospectionException ex) {
892 // no consequences for failure.
904 // no consequences for failure.
905 }
906 }
907 }
908 }
909 }
910 return result;
911 }
912
913 // Handle regular pd merge
914 private PropertyDescriptor mergePropertyDescriptor(PropertyDescriptor pd1,
915 PropertyDescriptor pd2) {
916 if (pd1.getClass0().isAssignableFrom(pd2.getClass0())) {
917 return new PropertyDescriptor(pd1, pd2);
918 } else {
919 return new PropertyDescriptor(pd2, pd1);
920 }
921 }
922
923 // Handle regular ipd merge
924 private IndexedPropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd1,
925 IndexedPropertyDescriptor ipd2) {
926 if (ipd1.getClass0().isAssignableFrom(ipd2.getClass0())) {
927 return new IndexedPropertyDescriptor(ipd1, ipd2);
928 } else {
929 return new IndexedPropertyDescriptor(ipd2, ipd1);
930 }
931 }
932
933 /**
934 * @return An array of EventSetDescriptors describing the kinds of
935 * events fired by the target bean.
936 */
937 private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
938 if (events == null) {
939 events = new HashMap<>();
940 }
941
942 // Check if the bean has its own BeanInfo that will provide
943 // explicit information.
944 EventSetDescriptor[] explicitEvents = null;
|