public AddFunction ( String name, IFunction func ) : |
||
name | String | /// The name of the function. /// |
func | IFunction | /// The IFunction instance to add. /// |
return |
/// <summary> /// Installs the plugin. /// </summary> public void Install() { var types = _assembly.GetTypes(); var elements = _context.Elements; foreach (var type in types) { if (!type.IsAbstract) { if (type.Name.EndsWith("Value", StringComparison.Ordinal)) { var value = Instantiate <IRegisterElement>(elements, type); value.RegisterElement(elements); _valueTypes.Add(type.Name.RemoveValueConvention()); } else { var interfaces = type.GetInterfaces(); var element = Instantiate <IRegisterElement>(elements, type, interfaces); if (element != null) { element.RegisterElement(elements); } var function = Instantiate <IFunction>(elements, type, interfaces); if (function != null) { bool isNested; var name = FunctionName(type, out isNested); _functions.Add(name); _context.AddFunction(name, function); } var constant = Instantiate <IConstants>(elements, type, interfaces); if (constant != null) { var name = constant.Name; _constants.Add(name); _context.AddConstant(name, constant); } var loader = Instantiate <IFunctionLoader>(elements, type, interfaces); if (loader != null) { _loaders.Add(loader); } } } } }
/// <summary> /// Registers the IFunction, IConstant and IRegisterToken token classes at the specified context. /// </summary> /// <param name="context"> /// The context where the IFunction and IConstant instances will be placed. /// </param> /// <param name="assembly"> /// The assembly to load. /// </param> /// <returns>The ID for the assembly.</returns> public int RegisterAssembly(ParseContext context, Assembly assembly) { var plugin = new Plugin(context, assembly.FullName); var types = assembly.GetTypes(); var ir = typeof(IRegisterElement).Name; var fu = typeof(IFunction).Name; var ct = typeof(IConstants).Name; foreach (var type in types) { if (type.IsAbstract) { continue; } if (type.Name.EndsWith("Value")) { var ctor = type.GetConstructor(Value.EmptyTypes); if (ctor != null) { (ctor.Invoke(null) as IRegisterElement).RegisterElement(); plugin.ValueTypes.Add(type.Name.RemoveValueConvention()); } continue; } var interfaces = type.GetInterfaces(); if (interfaces.Any(iface => iface.Name.Equals(ir))) { var ctor = type.GetConstructor(Value.EmptyTypes); if (ctor != null) { (ctor.Invoke(null) as IRegisterElement).RegisterElement(); } } if (interfaces.Any(iface => iface.Name.Equals(fu))) { var ctor = type.GetConstructor(Value.EmptyTypes); if (ctor != null) { var name = type.Name.RemoveFunctionConvention().ToLower(); var method = ctor.Invoke(null) as IFunction; plugin.Functions.Add(name); context.AddFunction(name, method); } } if (interfaces.Any(iface => iface.Name.Equals(ct))) { var ctor = type.GetConstructor(Value.EmptyTypes); if (ctor != null) { var instc = ctor.Invoke(null) as IConstants; plugin.Functions.Add(instc.Name); context.AddConstant(instc.Name, instc); } } } plugins.Add(plugin.Id, plugin); return(plugin.Id); }
/// <summary> /// Adds a custom function to be used by the parser using a specific context. /// </summary> /// <param name="context"> /// The context where this function should be made available. /// </param> /// <param name="name"> /// The name of the symbol corresponding to the function that should be added. /// </param> /// <param name="f"> /// The function that fulfills the signature Value f(Value v). /// </param> /// <returns>The given context.</returns> public static ParseContext AddCustomFunction(ParseContext context, string name, FunctionDelegate f) { context.AddFunction(name, new ContainerFunction(name, f)); return(context); }