public virtual T Create(InvocationHandler handler)
{
try
{
return(Constructor.newInstance(handler));
}
catch (Exception e)
{
throw new LinkageError("Failed to create proxy instance", e);
}
}
protected internal static T generateException <T>(Type exceptionClass, string message, string variableName, string description) where T : org.camunda.bpm.engine.ProcessEngineException
{
exceptionClass = typeof(T);
string formattedMessage = formatMessage(message, variableName, description);
try
{
System.Reflection.ConstructorInfo <T> constructor = exceptionClass.GetConstructor(typeof(string));
return(constructor.newInstance(formattedMessage));
}
catch (Exception e)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw LOG.exceptionWhileInstantiatingClass(exceptionClass.FullName, e);
}
}
/// <summary>
/// Create an ExpressionFactory instance.
/// </summary>
/// <param name="properties">
/// Properties passed to the constructor of the implementation. </param>
/// <returns> an instance of ExpressionFactory </returns>
/// <param name="className">
/// The name of the ExpressionFactory class. </param>
/// <param name="classLoader">
/// The class loader to be used to load the class. </param>
/// <returns> An instance of ExpressionFactory. </returns>
/// <exception cref="ELException">
/// if the class could not be found or if it is not a subclass of ExpressionFactory
/// or if the class could not be instantiated. </exception>
private static ExpressionFactory newInstance(Properties properties, string className, ClassLoader classLoader)
{
Type clazz = null;
try
{
clazz = classLoader.loadClass(className.Trim());
if (!clazz.IsAssignableFrom(typeof(ExpressionFactory)))
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new ELException("Invalid expression factory class: " + clazz.FullName);
}
}
catch (ClassNotFoundException e)
{
throw new ELException("Could not find expression factory class", e);
}
try
{
if (properties != null)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Constructor<?> constructor = null;
System.Reflection.ConstructorInfo <object> constructor = null;
try
{
constructor = clazz.GetConstructor(typeof(Properties));
}
catch (Exception)
{
// do nothing
}
if (constructor != null)
{
return((ExpressionFactory)constructor.newInstance(properties));
}
}
return((ExpressionFactory)System.Activator.CreateInstance(clazz));
}
catch (Exception e)
{
throw new ELException("Could not create expression factory instance", e);
}
}
/// <summary>
/// Creates a new instance of a class within one of the plug-ins
/// </summary>
/// <param name="classname"> The fully qualified name of the desired class </param>
/// <param name="argTypes"> An array of classes (fully qualified name) that specify the arguments to the constructor </param>
/// <param name="args"> An array of objects that will be the actual parameters to the constructor (the type should corresponds to the argTypes). </param>
/// <returns> a reference to the created instance. </returns>
/// <exception cref="MaltChainedException"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public Object newInstance(String classname, Class[] argTypes, Object[] args) throws org.maltparser.core.exception.MaltChainedException
public virtual object newInstance(string classname, Type[] argTypes, object[] args)
{
try
{
if (jarLoader == null)
{
return(null);
}
Type clazz = jarLoader.getClass(classname);
object o = null;
if (clazz == null)
{
return(null);
}
if (argTypes != null)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Constructor<?> constructor = clazz.getConstructor(argTypes);
System.Reflection.ConstructorInfo <object> constructor = clazz.GetConstructor(argTypes);
o = constructor.newInstance(args);
}
else
{
o = Activator.CreateInstance(clazz);
}
return(o);
}
catch (NoSuchMethodException e)
{
throw new PluginException("The plugin loader was not able to create an instance of the class '" + classname + "'. ", e);
}
catch (InstantiationException e)
{
throw new PluginException("The plugin loader was not able to create an instance of the class '" + classname + "'. ", e);
}
catch (IllegalAccessException e)
{
throw new PluginException("The plugin loader was not able to create an instance of the class '" + classname + "'. ", e);
}
catch (InvocationTargetException e)
{
throw new PluginException("The plugin loader was not able to create an instance of the class '" + classname + "'. ", e);
}
}
/// <summary>
/// Create the factory's builder. This implementation takes the
/// <code>de.odysseus.el.tree.TreeBuilder</code> property as a name of a class implementing the
/// <code>de.odysseus.el.tree.TreeBuilder</code> interface. If the property is not set, a plain
/// <code>de.odysseus.el.tree.impl.Builder</code> is used. If the configured class is a subclass
/// of <code>de.odysseus.el.tree.impl.Builder</code> and which provides a constructor taking an
/// array of <code>Builder.Feature</code>, this constructor will be invoked. Otherwise, the
/// default constructor will be used.
/// </summary>
protected internal virtual TreeBuilder createTreeBuilder(Properties properties, params Feature[] features)
{
Type clazz = load(typeof(TreeBuilder), properties);
if (clazz == null)
{
return(new Builder(features));
}
try
{
if (clazz.IsAssignableFrom(typeof(Builder)))
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Constructor<?> constructor = clazz.getConstructor(org.camunda.bpm.engine.impl.juel.Builder.Feature[].class);
System.Reflection.ConstructorInfo <object> constructor = clazz.GetConstructor(typeof(Feature[]));
if (constructor == null)
{
if (features == null || features.Length == 0)
{
return(typeof(TreeBuilder).cast(System.Activator.CreateInstance(clazz)));
}
else
{
throw new ELException("Builder " + clazz + " is missing constructor (can't pass features)");
}
}
else
{
return(typeof(TreeBuilder).cast(constructor.newInstance((object)features)));
}
}
else
{
return(typeof(TreeBuilder).cast(System.Activator.CreateInstance(clazz)));
}
}
catch (Exception e)
{
throw new ELException("TreeBuilder " + clazz + " could not be instantiated", e);
}
}
/// <summary>
/// Create a new instance of the provided type
/// </summary>
/// <param name="type"> the class to create a new instance of </param>
/// <param name="parameters"> the parameters to pass to the constructor </param>
/// <returns> the created instance </returns>
public static T createInstance <T>(Type type, params object[] parameters)
{
type = typeof(T);
// get types for parameters
Type[] parameterTypes = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
object parameter = parameters[i];
parameterTypes[i] = parameter.GetType();
}
try
{
// create instance
System.Reflection.ConstructorInfo <T> constructor = type.GetConstructor(parameterTypes);
return(constructor.newInstance(parameters));
}
catch (Exception e)
{
throw new ModelException("Exception while creating an instance of type " + type, e);
}
}
/// <summary>
/// Constructs an atomic model.
/// </summary>
/// <param name="index"> the index of the atomic model (-1..n), where -1 is special value (used by a single model
/// or the master divide model) and n is number of divide models. </param>
/// <param name="parent"> the parent guide model. </param>
/// <exception cref="MaltChainedException"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public AtomicModel(int index, org.maltparser.parser.guide.Model parent) throws org.maltparser.core.exception.MaltChainedException
public AtomicModel(int index, Model parent)
{
this.parent = parent;
this.index = index;
if (index == -1)
{
modelName = parent.ModelName + ".";
}
else
{
modelName = parent.ModelName + "." + (new Formatter()).format("%03d", index) + ".";
}
// this.featureVector = featureVector;
frequency = 0;
int?learnerMode = null;
if (Guide.GuideMode == ClassifierGuide_GuideMode.CLASSIFY)
{
learnerMode = LearningMethod_Fields.CLASSIFY;
}
else if (Guide.GuideMode == ClassifierGuide_GuideMode.BATCH)
{
learnerMode = LearningMethod_Fields.BATCH;
}
// start init learning method
Type clazz = (Type)Guide.Configuration.getOptionValue("guide", "learner");
if (clazz == typeof(LibSvm))
{
method = new LibSvm(this, learnerMode);
}
else if (clazz == typeof(LibLinear))
{
method = new LibLinear(this, learnerMode);
}
else
{
object[] arguments = new object[] { this, learnerMode };
try
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Constructor<?> constructor = clazz.getConstructor(argTypes);
System.Reflection.ConstructorInfo <object> constructor = clazz.GetConstructor(argTypes);
method = (LearningMethod)constructor.newInstance(arguments);
}
catch (NoSuchMethodException e)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new GuideException("The learner class '" + clazz.FullName + "' cannot be initialized. ", e);
}
catch (InstantiationException e)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new GuideException("The learner class '" + clazz.FullName + "' cannot be initialized. ", e);
}
catch (IllegalAccessException e)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new GuideException("The learner class '" + clazz.FullName + "' cannot be initialized. ", e);
}
catch (InvocationTargetException e)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new GuideException("The learner class '" + clazz.FullName + "' cannot be initialized. ", e);
}
}
// end init learning method
if (learnerMode.Value == LearningMethod_Fields.BATCH && index == -1 && Guide.Configuration != null)
{
Guide.Configuration.writeInfoToConfigFile(method.ToString());
}
}