667 // method if it starts with "is"
668 String gpdName = gpd.getReadMethod().getName();
669 if (gpdName.equals(pdName) || !gpdName.startsWith(IS_PREFIX)) {
670 gpd = new PropertyDescriptor(gpd, pd);
671 }
672 } else {
673 gpd = pd;
674 }
675 }
676 }
677 }
678
679 // Second pass. Find the latest setter method which
680 // has the same type as the getter method.
681 for (int i = 0; i < list.size(); i++) {
682 pd = list.get(i);
683 if (pd instanceof IndexedPropertyDescriptor) {
684 ipd = (IndexedPropertyDescriptor)pd;
685 if (ipd.getIndexedWriteMethod() != null) {
686 if (igpd != null) {
687 if (igpd.getIndexedPropertyType()
688 == ipd.getIndexedPropertyType()) {
689 if (ispd != null) {
690 ispd = new IndexedPropertyDescriptor(ispd, ipd);
691 } else {
692 ispd = ipd;
693 }
694 }
695 } else {
696 if (ispd != null) {
697 ispd = new IndexedPropertyDescriptor(ispd, ipd);
698 } else {
699 ispd = ipd;
700 }
701 }
702 }
703 } else {
704 if (pd.getWriteMethod() != null) {
705 if (gpd != null) {
706 if (gpd.getPropertyType() == pd.getPropertyType()) {
707 if (spd != null) {
708 spd = new PropertyDescriptor(spd, pd);
709 } else {
710 spd = pd;
711 }
712 }
713 } else {
714 if (spd != null) {
715 spd = new PropertyDescriptor(spd, pd);
716 } else {
717 spd = pd;
718 }
719 }
720 }
721 }
722 }
723
724 // At this stage we should have either PDs or IPDs for the
725 // representative getters and setters. The order at which the
726 // property descriptors are determined represent the
787 // PropertyDescriptor. If it does, then recreate as a
788 // PropertyDescriptor. See 4168833
789 if (pd instanceof IndexedPropertyDescriptor) {
790 ipd = (IndexedPropertyDescriptor)pd;
791 if (ipd.getIndexedReadMethod() == null && ipd.getIndexedWriteMethod() == null) {
792 pd = new PropertyDescriptor(ipd);
793 }
794 }
795
796 // Find the first property descriptor
797 // which does not have getter and setter methods.
798 // See regression bug 4984912.
799 if ( (pd == null) && (list.size() > 0) ) {
800 pd = list.get(0);
801 }
802
803 if (pd != null) {
804 properties.put(pd.getName(), pd);
805 }
806 }
807 }
808
809 /**
810 * Adds the property descriptor to the indexedproperty descriptor only if the
811 * types are the same.
812 *
813 * The most specific property descriptor will take precedence.
814 */
815 private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,
816 PropertyDescriptor pd) {
817 PropertyDescriptor result = null;
818
819 Class<?> propType = pd.getPropertyType();
820 Class<?> ipropType = ipd.getIndexedPropertyType();
821
822 if (propType.isArray() && propType.getComponentType() == ipropType) {
823 if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
824 result = new IndexedPropertyDescriptor(pd, ipd);
825 } else {
826 result = new IndexedPropertyDescriptor(ipd, pd);
|
667 // method if it starts with "is"
668 String gpdName = gpd.getReadMethod().getName();
669 if (gpdName.equals(pdName) || !gpdName.startsWith(IS_PREFIX)) {
670 gpd = new PropertyDescriptor(gpd, pd);
671 }
672 } else {
673 gpd = pd;
674 }
675 }
676 }
677 }
678
679 // Second pass. Find the latest setter method which
680 // has the same type as the getter method.
681 for (int i = 0; i < list.size(); i++) {
682 pd = list.get(i);
683 if (pd instanceof IndexedPropertyDescriptor) {
684 ipd = (IndexedPropertyDescriptor)pd;
685 if (ipd.getIndexedWriteMethod() != null) {
686 if (igpd != null) {
687 if (isAssignable(igpd.getIndexedPropertyType(), ipd.getIndexedPropertyType())) {
688 if (ispd != null) {
689 ispd = new IndexedPropertyDescriptor(ispd, ipd);
690 } else {
691 ispd = ipd;
692 }
693 }
694 } else {
695 if (ispd != null) {
696 ispd = new IndexedPropertyDescriptor(ispd, ipd);
697 } else {
698 ispd = ipd;
699 }
700 }
701 }
702 } else {
703 if (pd.getWriteMethod() != null) {
704 if (gpd != null) {
705 if (isAssignable(gpd.getPropertyType(), pd.getPropertyType())) {
706 if (spd != null) {
707 spd = new PropertyDescriptor(spd, pd);
708 } else {
709 spd = pd;
710 }
711 }
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
786 // PropertyDescriptor. If it does, then recreate as a
787 // PropertyDescriptor. See 4168833
788 if (pd instanceof IndexedPropertyDescriptor) {
789 ipd = (IndexedPropertyDescriptor)pd;
790 if (ipd.getIndexedReadMethod() == null && ipd.getIndexedWriteMethod() == null) {
791 pd = new PropertyDescriptor(ipd);
792 }
793 }
794
795 // Find the first property descriptor
796 // which does not have getter and setter methods.
797 // See regression bug 4984912.
798 if ( (pd == null) && (list.size() > 0) ) {
799 pd = list.get(0);
800 }
801
802 if (pd != null) {
803 properties.put(pd.getName(), pd);
804 }
805 }
806 }
807
808 private static boolean isAssignable(Class<?> current, Class<?> candidate) {
809 return current == null ? candidate == null : current.isAssignableFrom(candidate);
810 }
811
812 /**
813 * Adds the property descriptor to the indexedproperty descriptor only if the
814 * types are the same.
815 *
816 * The most specific property descriptor will take precedence.
817 */
818 private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,
819 PropertyDescriptor pd) {
820 PropertyDescriptor result = null;
821
822 Class<?> propType = pd.getPropertyType();
823 Class<?> ipropType = ipd.getIndexedPropertyType();
824
825 if (propType.isArray() && propType.getComponentType() == ipropType) {
826 if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
827 result = new IndexedPropertyDescriptor(pd, ipd);
828 } else {
829 result = new IndexedPropertyDescriptor(ipd, pd);
|