| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package flex.tools.debugger.cli; |
| |
| import java.util.HashMap; |
| |
| import flash.localization.LocalizationManager; |
| import flash.tools.debugger.events.DivideByZeroFault; |
| import flash.tools.debugger.events.ExceptionFault; |
| import flash.tools.debugger.events.InvalidTargetFault; |
| import flash.tools.debugger.events.InvalidURLFault; |
| import flash.tools.debugger.events.InvalidWithFault; |
| import flash.tools.debugger.events.ProtoLimitFault; |
| import flash.tools.debugger.events.RecursionLimitFault; |
| import flash.tools.debugger.events.ScriptTimeoutFault; |
| import flash.tools.debugger.events.StackUnderFlowFault; |
| |
| /** |
| * FaultActions proivdes a convenient wrapper for housing the user specified |
| * behaviour for a set of faults (aka text strings) |
| * |
| * The underlying data structure is a HashMap that maps strings (i.e. fault |
| * names) to Integers. The integers are used as bit fields for holding |
| * the state of setting per fault. |
| * |
| * Add new actions by calling addAction("name") |
| */ |
| public class FaultActions |
| { |
| HashMap<String, Integer> m_faults = new HashMap<String, Integer>(); |
| HashMap<String, String> m_description = new HashMap<String, String>(); // @todo should really use an object within the faults map for this |
| HashMap<String, Integer> m_actions = new HashMap<String, Integer>(); |
| |
| int m_nextBitForAction = 0x1; // the next bit to use for the action |
| |
| private FaultActions() {} |
| |
| Integer get(String o) { return m_faults.get(o); } |
| Integer getAction(String o) { return m_actions.get(o); } |
| void put(String k, Integer v){ m_faults.put(k,v); } |
| |
| /* getters */ |
| public void clear() { m_faults.clear(); } |
| public int size() { return m_faults.size(); } |
| public Object[] names() { return m_faults.keySet().toArray(); } |
| public Object[] actions() { return m_actions.keySet().toArray(); } |
| public boolean exists(String k) { return (get(k) == null) ? false : true; } |
| |
| public void putDescription(String k, String v) { m_description.put(k,v); } |
| public String getDescription(String k) { return (m_description.get(k) == null) ? "" : m_description.get(k); } //$NON-NLS-1$ |
| |
| /** |
| * Add a new fault to the table, with all actions disabled |
| */ |
| public void add(String k) |
| { |
| put(k, new Integer(0)); |
| } |
| |
| /** |
| * Add a new action type to the table |
| */ |
| public void addAction(String k) |
| { |
| Integer v = new Integer(m_nextBitForAction++); |
| m_actions.put(k,v); |
| } |
| |
| /** |
| * Check if the given fault has the action set or not |
| */ |
| public boolean is(String fault, String action) |
| { |
| int mask = getAction(action).intValue(); |
| int bits = get(fault).intValue(); |
| |
| boolean set = ( (bits & mask) == mask ) ? true : false; |
| return set; |
| } |
| |
| /** |
| * Sets the action bits as appropriate for the given fault |
| * and action |
| */ |
| public int action(String fault, String action) |
| { |
| // first check if fault is legal |
| Integer current = get(fault); |
| if (current == null) |
| throw new IllegalArgumentException(fault); |
| |
| // check for no? |
| boolean no = action.startsWith("no"); //$NON-NLS-1$ |
| if (no) |
| action = action.substring(2); |
| |
| // do the search for action |
| Integer bit = getAction(action); |
| if (bit == null) |
| throw new IllegalArgumentException(action); |
| |
| // now do the math |
| int old = current.intValue(); |
| int mask = bit.intValue(); |
| |
| int n = (old & (~mask)); // turn it off |
| n = (no) ? n : (n | mask); // leave it off or turn it on |
| |
| put(fault, new Integer(n)); |
| |
| return n; |
| } |
| |
| public static class FaultActionsBuilder { |
| |
| private final LocalizationManager localizationManager; |
| |
| public FaultActionsBuilder(LocalizationManager localizationManager) { |
| super(); |
| this.localizationManager = localizationManager; |
| } |
| |
| public FaultActions build() { |
| FaultActions faultActions = new FaultActions(); |
| populateFaultTable(faultActions); |
| return faultActions; |
| } |
| |
| private void populateFaultTable(FaultActions faultActions) { |
| // possible actions for our fault table |
| faultActions.addAction("stop"); //$NON-NLS-1$ |
| faultActions.addAction("print"); //$NON-NLS-1$ |
| |
| // the faults we support |
| faultActions.add(InvalidTargetFault.name); |
| faultActions.add(RecursionLimitFault.name); |
| faultActions.add(InvalidWithFault.name); |
| faultActions.add(ProtoLimitFault.name); |
| faultActions.add(InvalidURLFault.name); |
| faultActions.add(ExceptionFault.name); |
| faultActions.add(StackUnderFlowFault.name); |
| faultActions.add(DivideByZeroFault.name); |
| faultActions.add(ScriptTimeoutFault.name); |
| // faultActions.add(ConsoleErrorFault.name); |
| |
| // nice description of the faults |
| faultActions.putDescription( |
| InvalidTargetFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "invalidTargetFault")); //$NON-NLS-1$ |
| faultActions.putDescription( |
| RecursionLimitFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "recursionLimitFault")); //$NON-NLS-1$ |
| faultActions.putDescription( |
| InvalidWithFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "invalidWithFault")); //$NON-NLS-1$ |
| faultActions.putDescription( |
| ProtoLimitFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "protoLimitFault")); //$NON-NLS-1$ |
| faultActions.putDescription( |
| InvalidURLFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "invalidUrlFault")); //$NON-NLS-1$ |
| faultActions.putDescription( |
| ExceptionFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "exceptionFault")); //$NON-NLS-1$ |
| faultActions.putDescription( |
| StackUnderFlowFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "stackUnderflowFault")); //$NON-NLS-1$ |
| faultActions.putDescription( |
| DivideByZeroFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "divideByZeroFault")); //$NON-NLS-1$ |
| faultActions.putDescription( |
| ScriptTimeoutFault.name, |
| getLocalizationManager().getLocalizedTextString( |
| "scriptTimeoutFault")); //$NON-NLS-1$ |
| // faultActions.putDescription(ConsoleErrorFault.name, |
| // "ActionScript recoverable error"); |
| |
| // default values for the faults |
| faultActions.action(InvalidTargetFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(InvalidTargetFault.name, "print"); //$NON-NLS-1$ |
| faultActions.action(RecursionLimitFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(RecursionLimitFault.name, "print"); //$NON-NLS-1$ |
| faultActions.action(InvalidWithFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(InvalidWithFault.name, "print"); //$NON-NLS-1$ |
| faultActions.action(ProtoLimitFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(ProtoLimitFault.name, "print"); //$NON-NLS-1$ |
| faultActions.action(InvalidURLFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(InvalidURLFault.name, "print"); //$NON-NLS-1$ |
| faultActions.action(ExceptionFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(ExceptionFault.name, "print"); //$NON-NLS-1$ |
| faultActions.action(StackUnderFlowFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(StackUnderFlowFault.name, "print"); //$NON-NLS-1$ |
| faultActions.action(DivideByZeroFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(DivideByZeroFault.name, "print"); //$NON-NLS-1$ |
| faultActions.action(ScriptTimeoutFault.name, "stop"); //$NON-NLS-1$ |
| faultActions.action(ScriptTimeoutFault.name, "print"); //$NON-NLS-1$ |
| // faultActions.action(ConsoleErrorFault.name, "print"); //$NON-NLS-1$ |
| // faultActions.action(ConsoleErrorFault.name, "stop"); //$NON-NLS-1$ |
| } |
| |
| private LocalizationManager getLocalizationManager() { |
| return localizationManager; |
| } |
| } |
| } |
