• Home
• com.teamscale
• teamscale-lib-commons
• 2024.7.0-rc3
• source code
• OptionRegistry.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.conqat.lib.commons.options.OptionRegistry Maven / Gradle / Ivy

/*
 * Copyright (c) CQSE GmbH
 *
 * 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.
 */

package org.conqat.lib.commons.options;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.conqat.lib.commons.assertion.CCSMAssert;
import org.conqat.lib.commons.reflect.ReflectionUtils;

/**
 * This class supports collecting options from several objects whose methods have been annotated
 * with {@link Option}.
 *
 * @author Benjamin Hummel
 */
public class OptionRegistry {

	/** Mapping from short option names to actual option applicator. */
	private final Map shortOptions = new HashMap<>();

	/** Mapping from long option names to actual option applicator. */
	private final Map longOptions = new HashMap<>();

	/** List of all options (including description). */
	private final List allOptions = new ArrayList<>();

	/**
	 * Default constructor. Does nothing but we want to allow this too.
	 */
	public OptionRegistry() {
		// nothing to do
	}

	/**
	 * Construct a new option registry and register the given option handler.
	 *
	 * @param optionHandler
	 *            the option handler to register.
	 */
	public OptionRegistry(Object optionHandler) {
		registerOptionHandler(optionHandler);
	}

	/**
	 * Adds all options provided by the given object to this registry. Options are public methods
	 * annotated with AOption.
	 *
	 * @param optionHandler
	 *            The object to extract the options from.
	 */
	public void registerOptionHandler(Object optionHandler) {
		for (Method method : optionHandler.getClass().getMethods()) {
			Option optionDescriptor = method.getAnnotation(Option.class);
			if (optionDescriptor != null) {
				registerOption(optionHandler, method, optionDescriptor);
			}
		}

		for (Field field : ReflectionUtils.getAllFields(optionHandler.getClass())) {
			OptionHandler nestedHandler = field.getAnnotation(OptionHandler.class);
			if (nestedHandler != null) {
				try {
					field.setAccessible(true);
					Object nestedHandlerValue = field.get(optionHandler);
					CCSMAssert.isNotNull(nestedHandlerValue, () -> "Option handler " + field.getName() + " is null!");
					registerOptionHandler(nestedHandlerValue);
				} catch (IllegalAccessException e) {
					CCSMAssert.fail("Option handler " + field.getName() + " is not accessible!", e);
				}
			}
		}
	}

	private void registerOption(Object optionHandler, Method m, Option optionDescriptor) {
		allOptions.add(optionDescriptor);
		OptionApplicator applicator = new OptionApplicator(optionHandler, m, optionDescriptor.greedy());
		if (optionDescriptor.shortName() != 0) {
			registerApplicator(applicator, shortOptions, optionDescriptor.shortName());
		}
		if (optionDescriptor.longName().length() > 0) {
			registerApplicator(applicator, longOptions, optionDescriptor.longName());
		}
	}

	/**
	 * Registers an applicator under the given name in a map. Throws an exception if the name was
	 * already taken.
	 *
	 * @param 
	 *            type of the option name used in the map.
	 * @param applicator
	 *            the option applicator to register.
	 * @param map
	 *            the map to add the applicator to.
	 * @param optionName
	 *            the name of the option.
	 */
	private static  void registerApplicator(OptionApplicator applicator, Map map,
			T optionName) {
		if (map.containsKey(optionName)) {
			throw new IllegalArgumentException("An option of the name " + optionName + " already exists!");
		}
		map.put(optionName, applicator);
	}

	/**
	 * Returns the OptionApplicator for the given short option name or null if no such options exists.
	 *
	 * @param name
	 *            the name of the requested option.
	 * @return the OptionApplicator for the given short option name or null if no such options exists.
	 */
	public OptionApplicator getShortOption(char name) {
		return shortOptions.get(name);
	}

	/**
	 * Returns the OptionApplicator for the given short option name or null if no such options exists.
	 *
	 * @param name
	 *            the name of the requested option.
	 * @return the OptionApplicator for the given short option name or null if no such options exists.
	 */
	public OptionApplicator getLongOption(String name) {
		return longOptions.get(name);
	}

	/**
	 * Returns a list containing all supported options.
	 *
	 * @return a list containing all supported options.
	 */
	public List getAllOptions() {
		return allOptions;
	}
}