1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package com.vci.client.tool.panel;
 
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
 
import com.vci.client.common.PinyinCommon;
import com.vci.client.portal.utility.PRM;
import com.vci.client.portal.utility.PRMItem;
import com.vci.client.portal.utility.UITools;
import com.vci.client.tool.wrapper.PRMItemWrapper;
import com.vci.corba.portal.data.PortalVI;
 
/**
 * PortalVI 里name相同的PRMItem 查找器
 * @author xiongchao
 *
 */
public class PRMItemFinder {
    
    public PRMItemWrapper[] find(List<PortalVI> viList){
        PortalVI[] vis = viList.toArray(new PortalVI[]{});
        Arrays.sort(vis, new Comparator<PortalVI>() {
            @Override
            public int compare(PortalVI o1, PortalVI o2) {
                PRM p1 = UITools.getPRM(o1.prm);
                PRM p2 = UITools.getPRM(o2.prm);
                
                PRMItem[] items1 = p1.getPrmItemList().toArray(new PRMItem[] {});
                PRMItem[] items2 = p2.getPrmItemList().toArray(new PRMItem[] {});
 
                int len1 = items1.length;
                int len2 = items2.length;
                
                int res = 0;
                if(len1 < len2){
                    res = -1;
                }else if(len1 == len2){
                    res = 0;
                } else if(len1 > len2){
                    res = 1;
                }
                return res;
            }
        });
        return findDetail(vis);
    }
    
    private PRMItemWrapper[] findDetail(PortalVI[] vis){
        PRMItemWrapper[] res = new PRMItemWrapper[0];
        PRMItemWrapper[][] prmItems = new PRMItemWrapper[vis.length][];
        for (int i = 0; i < prmItems.length; i++) {
            prmItems[i] = getPortalVIPRMItemWrapperExs(vis[i]);
        }
        
        if(prmItems.length == 1){
            return prmItems[0];
        }
        List<PRMItemWrapper> list = new LinkedList<PRMItemWrapper>();
        for(PRMItemWrapper PRMItemWrapper : prmItems[0]){
            boolean existInAllOther = true;
            for (int i = 1; i < prmItems.length; i++) {
                existInAllOther = existInOtherPortalVIPRMItes(prmItems[i], PRMItemWrapper);
                if(!existInAllOther){
                    break;
                }
            }
            if(existInAllOther){
                list.add(PRMItemWrapper);
            }
        }
        
        res = list.toArray(new PRMItemWrapper[]{});
        
        return res;
    }
    
    private boolean existInOtherPortalVIPRMItes(PRMItemWrapper[] PRMItemWrapperExs, PRMItemWrapper PRMItemWrapper){
        boolean exist = true;
        for(PRMItemWrapper piw : PRMItemWrapperExs){
            exist = (piw.getPrmItem().getItemField().equals(PRMItemWrapper.getPrmItem().getItemField()));
            if(exist){
                break;
            }
        }
        return exist;
    }
    
    private PRMItemWrapper[] getPortalVIPRMItemWrapperExs(PortalVI vi){
        PRMItemWrapper[] res = new PRMItemWrapper[0];
        PRM prm = UITools.getPRM(vi.prm);
        PRMItem[] items = prm.getPrmItemList().toArray(new PRMItem[] {});
        Arrays.sort(items, new Comparator<PRMItem>() {
            public int compare(PRMItem o1, PRMItem o2) {
                return PinyinCommon.getPingYin(o1.getItemName()).compareTo(PinyinCommon.getPingYin(o2.getItemName()));
            }
        });
        Map<String, PRMItemWrapper> prmItemMap = convertToMap(items);
        PRMItemWrapper[] prmItems = convertToArrays(prmItemMap);
        res = prmItems;
        return res;
    }
    
    private PRMItemWrapper[] convertToArrays(Map<String, PRMItemWrapper> map){
        PRMItemWrapper[] res = new PRMItemWrapper[map.size()];
        Iterator<String> its = map.keySet().iterator();
        int i = 0;
        while(its.hasNext()){
            String key = its.next();
            PRMItemWrapper value = map.get(key);
            res[i++] = value;
        }
        return res;
    }
    private Map<String, PRMItemWrapper> convertToMap(PRMItem[] items){
        Map<String, PRMItemWrapper> map = new HashMap<String, PRMItemWrapper>();
        for (int i = 0; i < items.length; i++) {
            map.put(items[i].getItemField(), new PRMItemWrapper(items[i]));
        }
        return map;
    }
    
}