Java tutorial
/* * 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.pig.builtin; import java.io.IOException; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.Arrays; import java.util.List; import java.util.Set; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.pig.backend.executionengine.ExecException; import org.apache.pig.data.DataBag; import org.apache.pig.data.Tuple; import org.apache.pig.impl.PigContext; import org.apache.pig.impl.logicalLayer.FrontendException; import com.google.common.collect.Lists; import com.google.common.collect.Sets; public class Invoker<T> { private static final Log LOG = LogFactory.getLog(Invoker.class); private static final Class<?> DOUBLE_ARRAY_CLASS = new double[0].getClass(); private static final Class<?> INT_ARRAY_CLASS = new int[0].getClass(); private static final Class<?> FLOAT_ARRAY_CLASS = new float[0].getClass(); private static final Class<?> STRING_ARRAY_CLASS = new String[0].getClass(); private static final Class<?> LONG_ARRAY_CLASS = new long[0].getClass(); @SuppressWarnings("unchecked") private static final Set<Class<?>> ARRAY_CLASSES = Sets.newHashSet(DOUBLE_ARRAY_CLASS, INT_ARRAY_CLASS, FLOAT_ARRAY_CLASS, STRING_ARRAY_CLASS, LONG_ARRAY_CLASS); private Method method_; private Class<?>[] paramClasses_; private boolean isStatic_; private Class<?> selfClass_; private Type returnType_; public Invoker(String fullName, String paramSpecsStr) throws ClassNotFoundException, FrontendException, SecurityException, NoSuchMethodException { this(fullName, paramSpecsStr, "true"); } public Invoker(String fullName, String paramSpecsStr, String isStatic) throws ClassNotFoundException, FrontendException, SecurityException, NoSuchMethodException { String className = fullName.substring(0, fullName.lastIndexOf('.')); String methodName = fullName.substring(fullName.lastIndexOf('.') + 1); Class<?> klazz; try { klazz = PigContext.resolveClassName(className); } catch (IOException e) { // the amusing part is that PigContext throws this to wrap one of // the exceptions we declare! throw new FrontendException(e); } String[] paramSpecs = "".equals(paramSpecsStr) ? new String[0] : paramSpecsStr.split(" "); isStatic_ = "static".equalsIgnoreCase(isStatic) || "true".equals(isStatic); paramClasses_ = new Class<?>[paramSpecs.length]; for (int i = 0; i < paramSpecs.length; i++) { paramClasses_[i] = stringToClass(paramSpecs[i]); } if (!isStatic_) { selfClass_ = paramClasses_[0]; } method_ = klazz.getMethod(methodName, (isStatic_ ? paramClasses_ : dropFirstClass(paramClasses_))); returnType_ = method_.getGenericReturnType(); } @SuppressWarnings("rawtypes") public Type getReturnType() { return unPrimitivize((Class) returnType_); } private static Class<?>[] dropFirstClass(Class<?>[] original) { if (original.length < 2) { return new Class[0]; } else { return Arrays.copyOfRange(original, 1, original.length - 1); } } private static Object[] dropFirstObject(Object[] original) { if (original.length < 2) { return new Object[0]; } else { return Arrays.copyOfRange(original, 1, original.length - 1); } } private static Class<?> stringToClass(String klass) throws FrontendException { if ("string".equalsIgnoreCase(klass)) { return String.class; } else if ("int".equalsIgnoreCase(klass)) { return Integer.TYPE; } else if ("double".equalsIgnoreCase(klass)) { return Double.TYPE; } else if ("float".equalsIgnoreCase(klass)) { return Float.TYPE; } else if ("long".equalsIgnoreCase(klass)) { return Long.TYPE; } else if ("double[]".equalsIgnoreCase(klass)) { return DOUBLE_ARRAY_CLASS; } else if ("int[]".equalsIgnoreCase(klass)) { return INT_ARRAY_CLASS; } else if ("long[]".equalsIgnoreCase(klass)) { return LONG_ARRAY_CLASS; } else if ("float[]".equalsIgnoreCase(klass)) { return FLOAT_ARRAY_CLASS; } else if ("string[]".equalsIgnoreCase(klass)) { return STRING_ARRAY_CLASS; } else { throw new FrontendException("unable to find matching class for " + klass); } } private static Class<?> unPrimitivize(Class<?> klass) { if (klass.equals(Integer.TYPE)) { return Integer.class; } if (klass.equals(Long.TYPE)) { return Long.class; } else if (klass.equals(Float.TYPE)) { return Float.class; } else if (klass.equals(Double.TYPE)) { return Double.class; } else { return klass; } } private static <T> T convertToExpectedArg(Class<T> klass, Object obj) throws ExecException { if (ARRAY_CLASSES.contains(klass)) { DataBag dbag = (DataBag) obj; if (STRING_ARRAY_CLASS.equals(klass)) { List<String> dataList = Lists.newArrayList(); for (Tuple t : dbag) { dataList.add((String) t.get(0)); } String[] dataArray = new String[dataList.size()]; for (int i = 0; i < dataList.size(); i++) { dataArray[i] = dataList.get(i); } obj = dataArray; } else { List<Number> dataList = bagToNumberList(dbag); if (DOUBLE_ARRAY_CLASS.equals(klass)) { double[] dataArray = new double[dataList.size()]; for (int i = 0; i < dataList.size(); i++) { dataArray[i] = dataList.get(i).doubleValue(); } obj = dataArray; } else if (INT_ARRAY_CLASS.equals(klass)) { int[] dataArray = new int[dataList.size()]; for (int i = 0; i < dataList.size(); i++) { dataArray[i] = dataList.get(i).intValue(); } obj = dataArray; } else if (FLOAT_ARRAY_CLASS.equals(klass)) { float[] dataArray = new float[dataList.size()]; for (int i = 0; i < dataList.size(); i++) { dataArray[i] = dataList.get(i).floatValue(); } obj = dataArray; } else if (LONG_ARRAY_CLASS.equals(klass)) { long[] dataArray = new long[dataList.size()]; for (int i = 0; i < dataList.size(); i++) { dataArray[i] = dataList.get(i).longValue(); } obj = dataArray; } } } try { return klass.cast(obj); } catch (ClassCastException e) { LOG.error("Error in dynamic argument processing. Casting to: " + klass + " from: " + obj.getClass(), e); throw new ExecException(e); } } private static List<Number> bagToNumberList(DataBag dbag) throws ExecException { List<Number> dataList = Lists.newArrayList(); for (Tuple t : dbag) { dataList.add((Number) t.get(0)); } return dataList; } private Object[] tupleToArgs(Tuple t) throws ExecException { if ((t == null && (paramClasses_ != null || paramClasses_.length != 0)) || (t != null && t.size() < paramClasses_.length)) { throw new ExecException("unable to match function arguments to declared signature."); } if (t == null) { return null; } Object[] args = new Object[paramClasses_.length]; for (int i = 0; i < paramClasses_.length; i++) { args[i] = convertToExpectedArg(unPrimitivize(paramClasses_[i]), t.get(i)); } return args; } @SuppressWarnings("unchecked") public T invoke(Tuple input) throws IOException { Object[] args = tupleToArgs(input); try { if (!isStatic_) { return (T) method_.invoke(selfClass_.cast(args[0]), dropFirstObject(args)); } else { return (T) method_.invoke(null, args); } } catch (IllegalArgumentException e) { throw new ExecException(e); } catch (IllegalAccessException e) { throw new ExecException(e); } catch (InvocationTargetException e) { throw new ExecException(e); } } }