public <T1, T2> TypePairComparatorFactory<T1, T2> getPairComparatorFactory(ClassLoader cl) {
final String className = this.config.getString(DRIVER_PAIR_COMPARATOR_FACTORY, null);
if (className == null) {
return null;
}
@SuppressWarnings("unchecked")
final Class<TypePairComparatorFactory<T1, T2>> superClass =
(Class<TypePairComparatorFactory<T1, T2>>) (Class<?>) TypePairComparatorFactory.class;
try {
final Class<? extends TypePairComparatorFactory<T1, T2>> clazz =
Class.forName(className, true, cl).asSubclass(superClass);
return InstantiationUtil.instantiate(clazz, superClass);
} catch (ClassNotFoundException cnfex) {
throw new RuntimeException(
"The class '"
+ className
+ "', noted in the configuration as "
+ "pair comparator factory, could not be found. It is not part of the user code's class loader resources.");
} catch (ClassCastException ccex) {
throw new CorruptConfigurationException(
"The class noted in the configuration as the pair comparator factory "
+ "is no subclass of TypePairComparatorFactory.");
}
}
public void setStubWrapper(UserCodeWrapper<?> wrapper) {
try {
InstantiationUtil.writeObjectToConfig(wrapper, this.config, STUB_OBJECT);
} catch (IOException e) {
throw new CorruptConfigurationException(
"Could not write the user code wrapper " + wrapper.getClass() + " : " + e.toString(), e);
}
}
private final void setTypeComparatorFactory(
TypeComparatorFactory<?> factory, String classNameKey, String parametersPrefix) {
// sanity check the factory type
InstantiationUtil.checkForInstantiation(factory.getClass());
// store the type
this.config.setString(classNameKey, factory.getClass().getName());
// store the parameters
final DelegatingConfiguration parameters =
new DelegatingConfiguration(this.config, parametersPrefix);
factory.writeParametersToConfig(parameters);
}
@SuppressWarnings("unchecked")
public <T> UserCodeWrapper<T> getStubWrapper(ClassLoader cl) {
try {
return (UserCodeWrapper<T>)
InstantiationUtil.readObjectFromConfig(this.config, STUB_OBJECT, cl);
} catch (ClassNotFoundException e) {
throw new CorruptConfigurationException(
"Could not read the user code wrapper: " + e.getMessage(), e);
} catch (IOException e) {
throw new CorruptConfigurationException(
"Could not read the user code wrapper: " + e.getMessage(), e);
}
}
public DataDistribution getOutputDataDistribution(int outputNum, final ClassLoader cl)
throws ClassNotFoundException {
final String className = this.config.getString(OUTPUT_DATA_DISTRIBUTION_CLASS, null);
if (className == null) {
return null;
}
final Class<? extends DataDistribution> clazz;
try {
clazz =
(Class<? extends DataDistribution>)
Class.forName(className, true, cl).asSubclass(DataDistribution.class);
} catch (ClassCastException ccex) {
throw new CorruptConfigurationException(
"The class noted in the configuration as the data distribution "
+ "is no subclass of DataDistribution.");
}
final DataDistribution distribution =
InstantiationUtil.instantiate(clazz, DataDistribution.class);
final byte[] stateEncoded =
this.config.getBytes(OUTPUT_DATA_DISTRIBUTION_PREFIX + outputNum, null);
if (stateEncoded == null) {
throw new CorruptConfigurationException(
"The configuration contained the data distribution type, but no serialized state.");
}
final ByteArrayInputStream bais = new ByteArrayInputStream(stateEncoded);
final DataInputStream in = new DataInputStream(bais);
try {
distribution.read(in);
return distribution;
} catch (Exception ex) {
throw new RuntimeException(
"The deserialization of the encoded data distribution state caused an error"
+ ex.getMessage()
== null
? "."
: ": " + ex.getMessage(),
ex);
}
}
private final <T> TypeComparatorFactory<T> getTypeComparatorFactory(
String classNameKey, String parametersPrefix, ClassLoader cl) {
// check the class name
final String className = this.config.getString(classNameKey, null);
if (className == null) {
return null;
}
// instantiate the class
@SuppressWarnings("unchecked")
final Class<TypeComparatorFactory<T>> superClass =
(Class<TypeComparatorFactory<T>>) (Class<?>) TypeComparatorFactory.class;
final TypeComparatorFactory<T> factory;
try {
Class<? extends TypeComparatorFactory<T>> clazz =
Class.forName(className, true, cl).asSubclass(superClass);
factory = InstantiationUtil.instantiate(clazz, superClass);
} catch (ClassNotFoundException cnfex) {
throw new RuntimeException(
"The class '"
+ className
+ "', noted in the configuration as "
+ "comparator factory, could not be found. It is not part of the user code's class loader resources.");
} catch (ClassCastException ccex) {
throw new CorruptConfigurationException(
"The class noted in the configuration as the comparator factory "
+ "is no subclass of TypeComparatorFactory.");
}
// parameterize the comparator factory
final Configuration parameters = new DelegatingConfiguration(this.config, parametersPrefix);
try {
factory.readParametersFromConfig(parameters, cl);
} catch (ClassNotFoundException cnfex) {
throw new RuntimeException(
"The type serializer factory could not load its parameters from the "
+ "configuration due to missing classes.",
cnfex);
}
return factory;
}
public void setDriverPairComparator(TypePairComparatorFactory<?, ?> factory) {
final Class<?> clazz = factory.getClass();
InstantiationUtil.checkForInstantiation(clazz);
this.config.setString(DRIVER_PAIR_COMPARATOR_FACTORY, clazz.getName());
}