001    package org.maltparser.parser.history.action;
002    
003    import java.util.ArrayList;
004    
005    import org.maltparser.core.exception.MaltChainedException;
006    import org.maltparser.parser.history.GuideHistory;
007    import org.maltparser.parser.history.GuideUserHistory;
008    import org.maltparser.parser.history.HistoryException;
009    import org.maltparser.parser.history.History;
010    import org.maltparser.parser.history.container.ActionContainer;
011    import org.maltparser.parser.history.container.CombinedTableContainer;
012    import org.maltparser.parser.history.kbest.ScoredKBestList;
013    
014    /**
015    *
016    * @author Johan Hall
017    * @since 1.1
018    **/
019    public class ComplexDecisionAction implements GuideUserAction, MultipleDecision {
020            protected History history;
021            protected ArrayList<SimpleDecisionAction> decisions;
022            
023            public ComplexDecisionAction(History history) throws MaltChainedException {
024                    setHistory(history);
025                    initDecisions();
026            }
027            
028            public ComplexDecisionAction(GuideHistory history) throws MaltChainedException {
029                    setHistory((History)history);
030                    initDecisions();
031            }
032            
033            /* GuideUserAction interface */
034            public void addAction(ArrayList<ActionContainer> actionContainers) throws MaltChainedException {
035                    if (actionContainers == null || actionContainers.size() != history.getActionTables().size()) {
036                            throw new HistoryException("The action containers does not exist or is not of the same size as the action table. ");
037                    }
038                    int j = 0;
039                    for (int i = 0, n = history.getDecisionTables().size(); i < n; i++) {
040                            if (history.getDecisionTables().get(i) instanceof CombinedTableContainer) {
041                                    CombinedTableContainer tableContainer = (CombinedTableContainer)history.getDecisionTables().get(i);
042                                    int nContainers = tableContainer.getNumberContainers();
043                                    decisions.get(i).addDecision(tableContainer.getCombinedCode(actionContainers.subList(j, j + nContainers)));
044                                    j = j + nContainers;
045                            } else {
046                                    decisions.get(i).addDecision(actionContainers.get(j).getActionCode());
047                                    j++;
048                            }
049                    }
050            }
051            
052            public void getAction(ArrayList<ActionContainer> actionContainers) throws MaltChainedException {
053                    if (actionContainers == null || actionContainers.size() != history.getActionTables().size()) {
054                            throw new HistoryException("The action containers does not exist or is not of the same size as the action table. ");
055                    }
056                    int j = 0;
057                    for (int i = 0, n=history.getDecisionTables().size(); i < n; i++) {
058                            if (history.getDecisionTables().get(i) instanceof CombinedTableContainer) {
059                                    CombinedTableContainer tableContainer = (CombinedTableContainer)history.getDecisionTables().get(i);
060                                    int nContainers = tableContainer.getNumberContainers();
061                                    tableContainer.setActionContainer(actionContainers.subList(j, j + nContainers), decisions.get(i).getDecisionCode());
062                                    j = j + nContainers;
063                            } else {
064                                    actionContainers.get(j).setAction(decisions.get(i).getDecisionCode());
065                                    j++;
066                            }
067                    }
068            }
069            
070            public void addAction(ActionContainer[] actionContainers) throws MaltChainedException {
071                    if (actionContainers == null || actionContainers.length != history.getActionTables().size()) {
072                            throw new HistoryException("The action containers does not exist or is not of the same size as the action table. ");
073                    }
074                    int j = 0;
075                    for (int i = 0, n = history.getDecisionTables().size(); i < n; i++) {
076                            if (history.getDecisionTables().get(i) instanceof CombinedTableContainer) {
077                                    CombinedTableContainer tableContainer = (CombinedTableContainer)history.getDecisionTables().get(i);
078                                    int nContainers = tableContainer.getNumberContainers();
079                                    decisions.get(i).addDecision(tableContainer.getCombinedCode(actionContainers, j));
080                                    j = j + nContainers;
081                            } else {
082                                    decisions.get(i).addDecision(actionContainers[j].getActionCode());
083                                    j++;
084                            }
085                    }
086            }
087            
088            public void getAction(ActionContainer[] actionContainers) throws MaltChainedException {
089                    if (actionContainers == null || actionContainers.length != history.getActionTables().size()) {
090                            throw new HistoryException("The action containers does not exist or is not of the same size as the action table. ");
091                    }
092                    int j = 0;
093                    for (int i = 0, n=history.getDecisionTables().size(); i < n; i++) {
094                            if (history.getDecisionTables().get(i) instanceof CombinedTableContainer) {
095                                    CombinedTableContainer tableContainer = (CombinedTableContainer)history.getDecisionTables().get(i);
096                                    int nContainers = tableContainer.getNumberContainers();
097                                    tableContainer.setActionContainer(actionContainers, j, decisions.get(i).getDecisionCode());
098                                    j = j + nContainers;
099                            } else {
100                                    actionContainers[j].setAction(decisions.get(i).getDecisionCode());
101                                    j++;
102                            }
103                    }
104            }
105            
106            
107            public void getKBestLists(ArrayList<ScoredKBestList> kbestListContainers) throws MaltChainedException {
108    //              if (kbestListContainers == null || kbestListContainers.size() != history.getActionTables().size()) {
109    //                      throw new HistoryException("The action containers does not exist or is not of the same size as the action table. ");
110    //              }
111                    kbestListContainers.clear();
112                    for (int i = 0, n=decisions.size(); i < n; i++) {
113                            kbestListContainers.add((ScoredKBestList)decisions.get(i).getKBestList());
114                    }
115            }
116            
117            public void getKBestLists(ScoredKBestList[] kbestListContainers) throws MaltChainedException {
118                    for (int i = 0, n=decisions.size(); i < n; i++) {
119                            kbestListContainers[0] = (ScoredKBestList)decisions.get(i).getKBestList();
120                    }
121            }
122            
123            public int numberOfActions() {
124                    return history.getActionTables().size();
125            }
126            
127            public GuideUserHistory getGuideUserHistory() {
128                    return (GuideUserHistory)history;
129            }
130            
131            public void clear() {
132                    for (int i=0, n = decisions.size(); i < n;i++) {
133                            decisions.get(i).clear();
134                    }
135            }
136            
137            /* MultipleDecision */
138            public SingleDecision getSingleDecision(int decisionIndex) throws MaltChainedException {
139                    return decisions.get(decisionIndex);
140            }
141    
142            /* GuideDecision */
143            public int numberOfDecisions() {
144                    return history.getDecisionTables().size();
145            }
146    
147            public GuideHistory getGuideHistory() {
148                    return (GuideHistory)history;
149            }
150            
151            /* Initializer */
152            protected void initDecisions() throws MaltChainedException {
153                    decisions = new ArrayList<SimpleDecisionAction>(history.getDecisionTables().size());
154                    for (int i=0, n = history.getDecisionTables().size(); i < n; i++) {
155                            decisions.add(new SimpleDecisionAction(history, history.getDecisionTables().get(i)));
156                    }
157            }
158            
159            /* Getters and Setters */
160            protected void setHistory(History history) {
161                    this.history = history;
162            }
163    
164            public boolean equals(Object obj) {
165                    if (this == obj)
166                            return true;
167                    if (obj == null)
168                            return false;
169                    if (getClass() != obj.getClass())
170                            return false;
171                    ComplexDecisionAction other = (ComplexDecisionAction) obj;
172                    if (decisions == null) {
173                            if (other.decisions != null)
174                                    return false;
175                    } else if (decisions.size() != other.decisions.size()) {
176                            return false;
177                    } else {
178                            for (int i = 0; i < decisions.size(); i++) {
179                                    try {
180                                            if (decisions.get(i).getDecisionCode() != other.decisions.get(i).getDecisionCode()) {
181                                                    return false;
182                                            }
183                                    } catch (MaltChainedException e) {
184                                            System.out.println("Error in equals. ");
185                                    }
186                            }
187                    }
188                    
189                    return true;
190            }
191    
192            public String toString() {
193                    StringBuilder sb = new StringBuilder();
194                    for (int i = 0, n = decisions.size(); i < n; i++) {
195                            sb.append(decisions.get(i));
196                            sb.append(';');
197                    }
198                    if (sb.length() > 0) {
199                            sb.setLength(sb.length()-1);
200                    }
201                    return sb.toString();
202            }
203    }