org.apache.hadoop.fs.shell.find.ExpressionFactory Maven / Gradle / Ivy
/**
* 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 org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.util.ReflectionUtils;
import org.apache.hadoop.util.StringUtils;
/**
* Factory class for registering and searching for expressions for use in the
* {@link org.apache.hadoop.fs.shell.find.Find} command.
*/
final class ExpressionFactory {
private static final String REGISTER_EXPRESSION_METHOD = "registerExpression";
private Map> expressionMap =
new HashMap>();
private static final ExpressionFactory INSTANCE = new ExpressionFactory();
static ExpressionFactory getExpressionFactory() {
return INSTANCE;
}
/**
* Private constructor to ensure singleton.
*/
private ExpressionFactory() {
}
/**
* Invokes "static void registerExpression(FindExpressionFactory)" on the
* given class. This method abstracts the contract between the factory and the
* expression class. Do not assume that directly invoking registerExpression
* on the given class will have the same effect.
*
* @param expressionClass
* class to allow an opportunity to register
*/
void registerExpression(Class expressionClass) {
try {
Method register = expressionClass.getMethod(REGISTER_EXPRESSION_METHOD,
ExpressionFactory.class);
if (register != null) {
register.invoke(null, this);
}
} catch (Exception e) {
throw new RuntimeException(StringUtils.stringifyException(e));
}
}
/**
* Register the given class as handling the given list of expression names.
*
* @param expressionClass
* the class implementing the expression names
* @param names
* one or more command names that will invoke this class
* @throws IOException
* if the expression is not of an expected type
*/
void addClass(Class expressionClass,
String... names) throws IOException {
for (String name : names)
expressionMap.put(name, expressionClass);
}
/**
* Determines whether the given expression name represents and actual
* expression.
*
* @param expressionName
* name of the expression
* @return true if expressionName represents an expression
*/
boolean isExpression(String expressionName) {
return expressionMap.containsKey(expressionName);
}
/**
* Get an instance of the requested expression
*
* @param expressionName
* name of the command to lookup
* @param conf
* the Hadoop configuration
* @return the {@link Expression} or null if the expression is unknown
*/
Expression getExpression(String expressionName, Configuration conf) {
if (conf == null)
throw new NullPointerException("configuration is null");
Class expressionClass = expressionMap
.get(expressionName);
Expression instance = createExpression(expressionClass, conf);
return instance;
}
/**
* Creates an instance of the requested {@link Expression} class.
*
* @param expressionClass
* {@link Expression} class to be instantiated
* @param conf
* the Hadoop configuration
* @return a new instance of the requested {@link Expression} class
*/
Expression createExpression(
Class expressionClass, Configuration conf) {
Expression instance = null;
if (expressionClass != null) {
instance = ReflectionUtils.newInstance(expressionClass, conf);
}
return instance;
}
/**
* Creates an instance of the requested {@link Expression} class.
*
* @param expressionClassname
* name of the {@link Expression} class to be instantiated
* @param conf
* the Hadoop configuration
* @return a new instance of the requested {@link Expression} class
*/
Expression createExpression(String expressionClassname,
Configuration conf) {
try {
Class expressionClass = Class.forName(
expressionClassname).asSubclass(Expression.class);
return createExpression(expressionClass, conf);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Invalid classname "
+ expressionClassname);
}
}
}