| package com.yahoo.labs.samoa.moa.options; |
| |
| /* |
| * #%L |
| * SAMOA |
| * %% |
| * Copyright (C) 2007 University of Waikato, Hamilton, New Zealand |
| * %% |
| * Licensed 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. |
| * #L% |
| */ |
| |
| import java.util.HashMap; |
| import com.github.javacliparser.JavaCLIParser; |
| import com.github.javacliparser.Option; |
| import com.yahoo.labs.samoa.moa.core.ObjectRepository; |
| import com.yahoo.labs.samoa.moa.tasks.NullMonitor; |
| import com.yahoo.labs.samoa.moa.tasks.TaskMonitor; |
| |
| /* |
| * To change this template, choose Tools | Templates |
| * and open the template in the editor. |
| */ |
| |
| /** |
| * |
| * @author abifet |
| */ |
| public class OptionsHandler extends JavaCLIParser { |
| |
| // public Object handler; |
| |
| public OptionsHandler(Object c, String cliString) { |
| super(c, cliString); |
| // this.handler = c; |
| // this.prepareForUse(); |
| /* |
| * int firstSpaceIndex = cliString.indexOf(' ', 0); String classOptions; |
| * String className; if (firstSpaceIndex > 0) { className = |
| * cliString.substring(0, firstSpaceIndex); classOptions = |
| * cliString.substring(firstSpaceIndex + 1, cliString.length()); |
| * classOptions = classOptions.trim(); } else { className = cliString; |
| * classOptions = ""; } |
| */ |
| // options.setViaCLIString(cliString); |
| } |
| |
| // private static final long serialVersionUID = 1L; |
| |
| /** Options to handle */ |
| // protected Options options; |
| |
| /** Dictionary with option texts and objects */ |
| // protected Map<String, Object> classOptionNamesToPreparedObjects; |
| |
| /* |
| * public String getPurposeString() { return |
| * "Anonymous object: purpose undocumented."; } |
| * |
| * public Options getOptions() { if (this.options == null) { this.options = |
| * new Options(); Option[] myOptions = discoverOptionsViaReflection(); for |
| * (Option option : myOptions) { this.options.addOption(option); } } return |
| * this.options; } |
| */ |
| |
| public void prepareForUse() { |
| prepareForUse(new NullMonitor(), null); |
| } |
| |
| public void prepareForUse(TaskMonitor monitor, ObjectRepository repository) { |
| prepareClassOptions(monitor, repository); |
| // prepareForUseImpl(monitor, repository); |
| } |
| |
| /** |
| * This method describes the implementation of how to prepare this object for |
| * use. All classes that extends this class have to implement |
| * <code>prepareForUseImpl</code> and not <code>prepareForUse</code> since |
| * <code>prepareForUse</code> calls <code>prepareForUseImpl</code>. |
| * |
| * @param monitor |
| * the TaskMonitor to use |
| * @param repository |
| * the ObjectRepository to use |
| */ |
| // protected abstract void prepareForUseImpl(TaskMonitor monitor, |
| // ObjectRepository repository); |
| |
| /* |
| * public String getCLICreationString(Class<?> expectedType) { return |
| * ClassOption.stripPackagePrefix(this.getClass().getName(), expectedType) + |
| * " " + getOptions().getAsCLIString(); } |
| */ |
| |
| /** |
| * Gets the options of this class via reflection. |
| * |
| * @return an array of options |
| */ |
| /* |
| * public Option[] discoverOptionsViaReflection() { //Class<? extends |
| * AbstractOptionHandler> c = this.getClass(); Class c = |
| * this.handler.getClass(); Field[] fields = c.getFields(); List<Option> |
| * optList = new LinkedList<Option>(); for (Field field : fields) { String |
| * fName = field.getName(); Class<?> fType = field.getType(); if |
| * (fType.getName().endsWith("Option")) { if |
| * (Option.class.isAssignableFrom(fType)) { Option oVal = null; try { |
| * field.setAccessible(true); oVal = (Option) field.get(this.handler); } catch |
| * (IllegalAccessException ignored) { // cannot access this field } if (oVal |
| * != null) { optList.add(oVal); } } } } return optList.toArray(new |
| * Option[optList.size()]); } |
| */ |
| |
| /** |
| * Prepares the options of this class. |
| * |
| * @param monitor |
| * the TaskMonitor to use |
| * @param repository |
| * the ObjectRepository to use |
| */ |
| public void prepareClassOptions(TaskMonitor monitor, |
| ObjectRepository repository) { |
| this.classOptionNamesToPreparedObjects = null; |
| Option[] optionArray = getOptions().getOptionArray(); |
| for (Option option : optionArray) { |
| if (option instanceof ClassOption) { |
| ClassOption classOption = (ClassOption) option; |
| monitor.setCurrentActivity("Materializing option " |
| + classOption.getName() + "...", -1.0); |
| Object optionObj = classOption.materializeObject(monitor, |
| repository); |
| if (monitor.taskShouldAbort()) { |
| return; |
| } |
| if (optionObj instanceof OptionHandler) { |
| monitor.setCurrentActivity("Preparing option " |
| + classOption.getName() + "...", -1.0); |
| ((OptionHandler) optionObj).prepareForUse(monitor, |
| repository); |
| if (monitor.taskShouldAbort()) { |
| return; |
| } |
| } |
| if (this.classOptionNamesToPreparedObjects == null) { |
| this.classOptionNamesToPreparedObjects = new HashMap<String, Object>(); |
| } |
| this.classOptionNamesToPreparedObjects.put(option.getName(), |
| optionObj); |
| } |
| } |
| } |
| |
| /** |
| * Gets a prepared option of this class. |
| * |
| * @param opt |
| * the class option to get |
| * @return an option stored in the dictionary |
| */ |
| public Object getPreparedClassOption(ClassOption opt) { |
| if (this.classOptionNamesToPreparedObjects == null) { |
| this.prepareForUse(); |
| } |
| return this.classOptionNamesToPreparedObjects.get(opt.getName()); |
| } |
| |
| // @Override |
| // public void getDescription(StringBuilder sb, int i) { |
| // throw new UnsupportedOperationException("Not supported yet."); |
| // } |
| |
| } |