public ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec)
{
int nIncomingArgs = args.Length;
if (nIncomingArgs < 1)
{
throw new Exception("function name argument missing");
}
ValueEval nameArg = args[0];
String functionName = string.Empty;
if (nameArg is FunctionNameEval)
{
functionName = ((FunctionNameEval)nameArg).FunctionName;
}
else
{
throw new Exception("First argument should be a NameEval, but got ("
+ nameArg.GetType().Name + ")");
}
FreeRefFunction targetFunc = ec.FindUserDefinedFunction(functionName);
if (targetFunc == null)
{
throw new NotImplementedFunctionException(functionName);
}
int nOutGoingArgs = nIncomingArgs - 1;
ValueEval[] outGoingArgs = new ValueEval[nOutGoingArgs];
Array.Copy(args, 1, outGoingArgs, 0, nOutGoingArgs);
return(targetFunc.Evaluate(outGoingArgs, ec));
}
/**
* Register a ATP function in runtime.
*
* @param name the function name
* @param func the functoin to register
* @throws ArgumentException if the function is unknown or already registered.
* @since 3.8 beta6
*/
public static void RegisterFunction(String name, FreeRefFunction func)
{
AnalysisToolPak inst = (AnalysisToolPak)instance;
if (!IsATPFunction(name))
{
FunctionMetadata metaData = FunctionMetadataRegistry.GetFunctionByName(name);
if (metaData != null)
{
throw new ArgumentException(name + " is a built-in Excel function. " +
"Use FunctoinEval.RegisterFunction(String name, Function func) instead.");
}
else
{
throw new ArgumentException(name + " is not a function from the Excel Analysis Toolpack.");
}
}
FreeRefFunction f = inst.FindFunction(name);
if (f != null && !(f is NotImplemented))
{
throw new ArgumentException("POI already implememts " + name +
". You cannot override POI's implementations of Excel functions");
}
if (_functionsByName.ContainsKey(name))
{
_functionsByName[name] = func;
}
else
{
_functionsByName.Add(name, func);
}
}
public override FreeRefFunction FindFunction(string name)
{
FreeRefFunction function = base.FindFunction(name);
if (function != null)
{
this._funcMap[this.GetFunctionIndex(name)] = name;
}
return(function);
}
public override FreeRefFunction FindFunction(String name)
{
FreeRefFunction func = base.FindFunction(name);
if (func != null)
{
int idx = GetFunctionIndex(name);
_funcMap[idx] = name;
}
return(func);
}
/**
* returns the OperationEval concrete impl instance corresponding
* to the supplied operationPtg
*/
public static ValueEval Evaluate(OperationPtg ptg, ValueEval[] args,
OperationEvaluationContext ec)
{
if (ptg == null)
{
throw new ArgumentException("ptg must not be null");
}
NPOI.SS.Formula.Functions.Function result = _instancesByPtgClass[ptg] as NPOI.SS.Formula.Functions.Function;
FreeRefFunction udfFunc = null;
if (result == null)
{
if (ptg is AbstractFunctionPtg)
{
AbstractFunctionPtg fptg = (AbstractFunctionPtg)ptg;
int functionIndex = fptg.FunctionIndex;
switch (functionIndex)
{
case NPOI.SS.Formula.Function.FunctionMetadataRegistry.FUNCTION_INDEX_INDIRECT:
udfFunc = Indirect.instance;
break;
case NPOI.SS.Formula.Function.FunctionMetadataRegistry.FUNCTION_INDEX_EXTERNAL:
udfFunc = UserDefinedFunction.instance;
break;
default:
result = FunctionEval.GetBasicFunction(functionIndex);
break;
}
}
}
if (result != null)
{
if (result is ArrayFunction)
{
ArrayFunction func = (ArrayFunction)result;
ValueEval eval = EvaluateArrayFunction(func, args, ec);
if (eval != null)
{
return(eval);
}
}
return(result.Evaluate(args, ec.RowIndex, (short)ec.ColumnIndex));
}
else if (udfFunc != null)
{
return(udfFunc.Evaluate(args, ec));
}
throw new Exception("Unexpected operation ptg class (" + ptg.GetType().Name + ")");
}
public NameXPtg GetNameXPtg(String name)
{
IndexedUDFFinder udfFinder = (IndexedUDFFinder)GetUDFFinder();
FreeRefFunction func = udfFinder.FindFunction(name);
if (func == null)
{
return(null);
}
else
{
return(new NameXPtg(0, udfFinder.GetFunctionIndex(name)));
}
}
/**
* Returns a collection of ATP function names NOT implemented by POI.
*
* @return an array of not supported functions
* @since 3.8 beta6
*/
public static ReadOnlyCollection <String> GetNotSupportedFunctionNames()
{
AnalysisToolPak inst = (AnalysisToolPak)instance;
List <String> lst = new List <String>();
foreach (String name in AnalysisToolPak._functionsByName.Keys)
{
FreeRefFunction func = (FreeRefFunction)AnalysisToolPak._functionsByName[(name)];
if (func != null && (func is NotImplemented))
{
lst.Add(name);
}
}
return(lst.AsReadOnly()); //Collections.unmodifiableCollection(lst);
}
public DefaultUDFFinder(String[] functionNames, FreeRefFunction[] functionImpls)
{
int nFuncs = functionNames.Length;
if (functionImpls.Length != nFuncs)
{
throw new ArgumentException(
"Mismatch in number of function names and implementations");
}
Dictionary<String, FreeRefFunction> m = new Dictionary<String, FreeRefFunction>(nFuncs * 3 / 2);
for (int i = 0; i < functionImpls.Length; i++)
{
m[functionNames[i].ToUpper()]= functionImpls[i];
}
_functionsByName = m;
}
/**
* Returns a collection of ATP function names implemented by POI.
*
* @return an array of supported functions
* @since 3.8 beta6
*/
public static ReadOnlyCollection <String> GetSupportedFunctionNames()
{
AnalysisToolPak inst = (AnalysisToolPak)instance;
List <String> lst = new List <String>();
foreach (KeyValuePair <String, FreeRefFunction> me in AnalysisToolPak._functionsByName)
{
FreeRefFunction func = me.Value;
if (func != null && !(func is NotImplemented))
{
lst.Add(me.Key);
}
}
return(lst.AsReadOnly()); //Collections.unmodifiableCollection(lst);
}
/// <summary>
/// Return an external name (named range, function, user-defined function) Pxg
/// </summary>
/// <param name="name"></param>
/// <param name="sheet"></param>
/// <returns></returns>
public Ptg GetNameXPtg(String name, SheetIdentifier sheet)
{
// First, try to find it as a User Defined Function
IndexedUDFFinder udfFinder = (IndexedUDFFinder)GetUDFFinder();
FreeRefFunction func = udfFinder.FindFunction(name);
if (func != null)
{
return(new NameXPxg(null, name));
}
// Otherwise, try it as a named range
if (sheet == null)
{
if (_uBook.GetNames(name).Count > 0)
{
return(new NameXPxg(null, name));
}
return(null);
}
if (sheet._sheetIdentifier == null)
{
// Workbook + Named Range only
int bookIndex = ResolveBookIndex(sheet._bookName);
return(new NameXPxg(bookIndex, null, name));
}
// Use the sheetname and process
String sheetName = sheet._sheetIdentifier.Name;
if (sheet._bookName != null)
{
int bookIndex = ResolveBookIndex(sheet._bookName);
return(new NameXPxg(bookIndex, sheetName, name));
}
else
{
return(new NameXPxg(sheetName, name));
}
}
private static void r(Hashtable m, String functionName, FreeRefFunction pFunc)
{
FreeRefFunction func = pFunc == null ? new NotImplemented(functionName) : pFunc;
m[functionName] = func;
}
/**
* Register a ATP function in runtime.
*
* @param name the function name
* @param func the functoin to register
* @throws ArgumentException if the function is unknown or already registered.
* @since 3.8 beta6
*/
public static void RegisterFunction(String name, FreeRefFunction func)
{
AnalysisToolPak inst = (AnalysisToolPak)instance;
if (!IsATPFunction(name))
{
FunctionMetadata metaData = FunctionMetadataRegistry.GetFunctionByName(name);
if (metaData != null)
{
throw new ArgumentException(name + " is a built-in Excel function. " +
"Use FunctoinEval.RegisterFunction(String name, Function func) instead.");
}
else
{
throw new ArgumentException(name + " is not a function from the Excel Analysis Toolpack.");
}
}
FreeRefFunction f = inst.FindFunction(name);
if (f != null && !(f is NotImplemented))
{
throw new ArgumentException("POI already implememts " + name +
". You cannot override POI's implementations of Excel functions");
}
if (_functionsByName.ContainsKey(name))
_functionsByName[name] = func;
else
_functionsByName.Add(name, func);
}
private static void r(Hashtable m, String functionName, FreeRefFunction pFunc)
{
FreeRefFunction func = pFunc == null ? new NotImplemented(functionName) : pFunc;
m[functionName] = func;
}
private static void r(Dictionary <object, object> m, String functionName, FreeRefFunction pFunc)
{
FreeRefFunction func = pFunc == null ? new NotImplemented(functionName) : pFunc;
m[functionName] = func;
}
/**
* Register a ATP function in runtime.
*
* @param name the function name
* @param func the functoin to register
* @throws IllegalArgumentException if the function is unknown or already registered.
* @since 3.8 beta6
*/
public static void RegisterFunction(String name, FreeRefFunction func)
{
AnalysisToolPak.RegisterFunction(name, func);
}
private static void AddMapping(Hashtable m, int offset, FreeRefFunction frf)
{
m[CreateFRFKey(offset)] = frf;
}
/**
* Register a ATP function in runtime.
*
* @param name the function name
* @param func the functoin to register
* @throws IllegalArgumentException if the function is unknown or already registered.
* @since 3.8 beta6
*/
public static void RegisterFunction(string name, FreeRefFunction func)
{
AnalysisToolPak.RegisterFunction(name, func);
}
protected void ConfirmFindFunction(String name)
{
FreeRefFunction func = _instance.FindFunction(name);
Assert.IsNotNull(func);
}
