// For functional testing public static ParseResult <object> ParseMethod(string exprString, IFunctions <string> functions = null) { var parseResult = CSharpParser(functions).Parse(exprString); if (!parseResult.Success) { return(new ParseResult <object>(parseResult.ParseErrors)); } var expr = parseResult.Expression; var csharpExpr = expr.Evaluate(new CSharpObjectContext(ConcatStringMonad.Instance, Constants.DefaultContext)); var(type, emitResult) = CodeGenCSharpClass.Generate("VcelTesting", csharpExpr); if (type == null) { return(new ParseResult <object>(emitResult.Diagnostics.Select( x => new ParseError( x.GetMessage(), x.Id, x.Location.GetLineSpan().StartLinePosition.Line, x.Location.GetLineSpan().StartLinePosition.Line, x.Location.GetLineSpan().EndLinePosition.Line)).ToList())); } var method = type.GetMethod("Evaluate"); return(new ParseResult <object>(new CSharpMethodExpr(null, method))); }
/// <summary> /// The Common Call Function expanded for multiple functions. /// </summary> public void Call(List <string> functionNames, params object[] args) { bool ranLUAArgs = false; DynValue[] luaArgs = null; for (int i = 0; i < functionNames.Count; i++) { if (functionNames[i] == null) { UnityDebugger.Debugger.LogError(ModFunctionsLogChannel, "'" + functionNames[i] + "' is not a LUA nor CSharp function!"); continue; } IFunctions functions = GetFunctions(functionNames[i]); if (functions is LuaFunctions) { if (ranLUAArgs == false) { luaArgs = new DynValue[args.Length]; for (int j = 0; j < args.Length; j++) { luaArgs[j] = functions.CreateInstance(args[j]); } } Call(functionNames[i], false, luaArgs); } else { Call(functionNames[i], false, args); } } }
// For performance testing public static ParseResult <object> ParseDelegate(string exprString, IFunctions <string> functions = null) { var parseResult = CSharpParser(functions).Parse(exprString); var expr = parseResult.Expression; var csharpExpr = expr.Evaluate(new CSharpObjectContext(ConcatStringMonad.Instance, Constants.DefaultContext)); var(type, emitResult) = CodeGenCSharpClass.Generate("VcelTesting", csharpExpr); if (type == null) { return(new ParseResult <object>(emitResult.Diagnostics.Select( x => new ParseError( x.GetMessage(), x.Id, x.Location.GetLineSpan().StartLinePosition.Line, x.Location.GetLineSpan().StartLinePosition.Line, x.Location.GetLineSpan().EndLinePosition.Line)).ToList())); } var method = type.GetMethod("Evaluate"); Debug.Assert(method != null, nameof(method) + " != null"); var func = (Func <object, object>)Delegate.CreateDelegate(typeof(Func <object, object>), null, method); return(new ParseResult <object>(new CSharpDelegateExpr(null, func))); }
public ExpressionFactory( IMonad <T> monad, IFunctions <T> functions = null) { Monad = monad; Functions = functions ?? new DefaultFunctions <T>(); }
public ParsedEquation(IFunctions functions) { var k = Parse <Func <double, double, double, double> >(functions.K, "x", "t", "u").Compile(); K = (x, t, u) => k(x, t, u); var dK_duFunc = Parse <Func <double, double, double, double> >(functions.dK_du, "x", "t", "u").Compile(); dK_du = (x, t, u) => dK_duFunc(x, t, u); var gFunc = Parse <Func <double, double, double, double, double> >(functions.g, "x", "t", "u", "K").Compile(); g = (x, t, u) => gFunc(x, t, u, K(x, t, u)); var initCond = Parse <Func <double, double> >(functions.InitCond, "x").Compile(); InitCond = x => initCond(x); var leftBoundCond = Parse <Func <double, double> >(functions.LeftBoundCond, "t").Compile(); LeftBoundCond = t => leftBoundCond(t); var rightBoundCond = Parse <Func <double, double> >(functions.RightBoundCond, "t").Compile(); RightBoundCond = t => rightBoundCond(t); u = Compile(functions.u); du_dx = Compile(functions.du_dx); d2u_dx2 = Compile(functions.d2u_dx2); du_dt = Compile(functions.du_dt); }
public Implementation(IFunctions functions, IOptions <Configuration> options, ILogger <Implementation> logger) { _functions = functions; _options = options; _logger = logger; (_entryPoint, _completion) = CreatePipeline(); }
public ListExpressionFactory( IMonad <List <object> > monad, IFunctions <List <object> > functions = null) : base( monad, functions ?? new DefaultFunctions <List <object> >()) { }
public TransformationumlToRdbms(IMetaModelInterface editor, IFunctions Functions) { this.editor = editor; this.RelationPackageToSchema = new RelationPackageToSchema(editor, this); this.Functions = Functions; this.RelationClassToTable = new RelationClassToTable(editor, this); this.Functions = Functions; this.RelationPrimitiveAttributeToColumn = new RelationPrimitiveAttributeToColumn(editor, this); this.Functions = Functions; this.RelationComplexAttributeToColumn = new RelationComplexAttributeToColumn(editor, this); this.Functions = Functions; this.RelationSuperAttributeToColumn = new RelationSuperAttributeToColumn(editor, this); this.Functions = Functions; this.RelationAssocToFKey = new RelationAssocToFKey(editor, this); this.Functions = Functions; this.RelationAttributeToColumn = new RelationAttributeToColumn(editor, this); this.Functions = Functions; }
public ToCSharpFunction( IMonad <string> monad, string name, IReadOnlyList <IExpression <string> > args, IFunctions <string> functions) { this.Monad = monad; this.name = name; this.args = args; this.functions = functions ?? new DefaultCSharpFunctions(); }
public bool FSelect(IFunctions Name) { lock (WriteLock) { if (IFunctionsClass.ServerList[_servername].Functions.ContainsKey(Name.ToString().ToLower())) { return(IFunctionsClass.ServerList[_servername].Functions[Name.ToString().ToLower()] == SchumixBase.On); } return(false); } }
// For functional testing public static ParseResult <string> ParseCode(string exprString, IFunctions <string> functions = null) { var parseResult = CSharpParser(functions).Parse(exprString); if (!parseResult.Success) { return(new ParseResult <string>(parseResult.ParseErrors)); } var csharpString = parseResult.Expression.Evaluate(new CSharpObjectContext(ConcatStringMonad.Instance, Constants.DefaultContext)); return(new ParseResult <string>(new CSharpStringExpr(null, csharpString))); }
public T Call <T>(string functionName, params object[] args) { IFunctions functions = GetFunctions(functionName); if (functions != null) { return(functions.Call <T>(functionName, args)); } else { Debug.ULogChannel(ModFunctionsLogChannel, "'" + functionName + "' is not a LUA nor CSharp function!"); return(default(T)); } }
/// <summary> /// Try get function. /// </summary> /// <param name="functions"></param> /// <param name="functionName"></param> /// <param name="func"></param> /// <returns></returns> public static bool TryGetValue(this IFunctions functions, string functionName, out IFunction func) { if (functions == null) { throw new ArgumentNullException(nameof(functions)); } if (functionName == null) { throw new ArgumentNullException(nameof(functionName)); } if (functions is IFunctionsQueryable queryable) { return(queryable.TryGetValue(functionName, out func)); } func = null; return(false); }
static Functions() { dbType = ConfigurationManager.AppSettings["dbType"].ToUpper(); switch (dbType) { case "SQL": providerFunctions = new DocsPaDbManagement.Functions.SqlServer.Functions(); break; case "ORACLE": providerFunctions = new DocsPaDbManagement.Functions.Oracle.Functions(); break; //case "ORACLENATIVE": // providerFunctions = new DocsPaDbManagement.Functions.OracleNative.Functions(); // break; } }
/// <summary> /// Try get function. /// </summary> /// <param name="functions"></param> /// <param name="functionName"></param> /// <returns>function</returns> /// <exception cref="InvalidOperationException">If </exception> /// <exception cref="KeyNotFoundException">If function is not found</exception> public static IFunction GetValue(this IFunctions functions, string functionName) { if (functions == null) { throw new ArgumentNullException(nameof(functions)); } if (functionName == null) { throw new ArgumentNullException(nameof(functionName)); } IFunction func; if (functions is IFunctionsQueryable queryable && queryable.TryGetValue(functionName, out func)) { return(func); } throw new KeyNotFoundException(functionName); }
private DynValue Call(string functionName, bool throwError, params object[] args) { IFunctions functions = GetFunctions(functionName); if (functions != null) { return(functions.Call(functionName, args)); } else { UnityDebugger.Debugger.Log(ModFunctionsLogChannel, "'" + functionName + "' is not a LUA nor is it a CSharp function!"); if (throwError) { throw new Exception("'" + functionName + "' is not a LUA nor is it a CSharp function!"); } return(null); } }
public T CreateInstance <T>(string className, bool throwError, params object[] args) { string fullClassName = className + (args.Length > 0 ? string.Join(",", args.Select(x => x.GetType().Name).ToArray()) : string.Empty); IFunctions functions = GetFunctions(fullClassName, true); if (functions != null) { return(functions.CreateInstance <T>(fullClassName, args)); } else { UnityDebugger.Debugger.Log(ModFunctionsLogChannel, "'" + className + "' is not a LUA function nor is it a CSharp constructor!"); if (throwError) { throw new Exception("'" + className + "' is not a LUA function nor is it a CSharp constructor!"); } return(default(T)); } }
/// <summary> /// Call 0-arguments function. /// </summary> /// <param name="functions"></param> /// <param name="functionName"></param> /// <param name="ctx"></param> /// <param name="result">Object, String, Long, Double or null</param> /// <returns>true if evaluated, false if not</returns> /// <exception cref="Exception">On unexpected error</exception> public static bool TryEvaluate(this IFunctions functions, string functionName, ref FunctionEvaluationContext ctx, out object result) { if (functions == null || functionName == null) { result = null; return(false); } IFunction func; if (functions is IFunctionsQueryable queryable && queryable.TryGetValue(functionName, out func)) { if (func is IFunction0 func0 && func0.TryEvaluate(ref ctx, out result)) { return(true); } if (func is IFunctionN funcN && funcN.TryEvaluate(ref ctx, no_args, out result)) { return(true); } } result = null; return(false); }
/// <summary> /// Call 3-argument function. /// </summary> /// <param name="functions"></param> /// <param name="functionName"></param> /// <param name="ctx"></param> /// <param name="arg0">Function argument</param> /// <param name="arg1"></param> /// <param name="arg2"></param> /// <param name="result">Object, String, Long, Double or null</param> /// <returns>true if evaluated, false if not</returns> /// <exception cref="Exception">On unexpected error</exception> public static bool TryEvaluate(this IFunctions functions, string functionName, ref FunctionEvaluationContext ctx, object arg0, object arg1, object arg2, out object result) { if (functions == null || functionName == null) { result = null; return(false); } IFunction func; if (functions is IFunctionsQueryable queryable && queryable.TryGetValue(functionName, out func)) { if (func is IFunction3 func3 && func3.TryEvaluate(ref ctx, arg0, arg1, arg2, out result)) { return(true); } if (func is IFunctionN funcN && funcN.TryEvaluate(ref ctx, new object[] { arg0, arg1, arg2 }, out result)) { return(true); } } result = null; return(false); }
/// <summary> /// Search linked list and finds the effective (left-most) <see cref="ILineFunctions"/> key. /// /// Returns parameter "Functions" value as <see cref="IFunctions"/>, if <paramref name="resolver"/> is provided. /// /// If implements <see cref="ILineFunctions"/> returns the type. /// </summary> /// <param name="line"></param> /// <param name="resolver">(optional) type resolver that resolves "IFunctions" parameter into type. Returns null, if could not resolve, exception if resolve fails</param> /// <returns>type info or null</returns> /// <exception cref="Exception">from <paramref name="resolver"/></exception> public static IFunctions FindFunctions(this ILine line, IResolver resolver = null) { IFunctions type = null; for (ILine l = line; l != null; l = l.GetPreviousPart()) { if (l is ILineFunctions part && part.Functions != null) { type = part.Functions; continue; } if (resolver != null && l is ILineParameterEnumerable lineParameters) { IFunctions tt = null; foreach (ILineParameter parameter in lineParameters) { if (parameter.ParameterName == "Functions" && parameter.ParameterValue != null) { tt = resolver.Resolve <IFunctions>(parameter.ParameterValue); if (tt != null) { break; } } } if (tt != null) { type = tt; continue; } } if (resolver != null && l is ILineParameter lineParameter && lineParameter.ParameterName == "Functions" && lineParameter.ParameterValue != null) { IFunctions t = resolver.Resolve <IFunctions>(lineParameter.ParameterValue); if (t != null) { type = t; } } } return(type); }
public static double CalculateVolume(double height, string heightUnits, double length, string lengthUnits, double width, string widthUnits, string volumeUnits) { //Initialise Tedds #if USE_TEDDS_CALC_IA_REF ICalculator teddsCalc = new Calculator(); #else dynamic teddsCalc = Activator.CreateInstance(Type.GetTypeFromProgID("Tedds.Calculator")); #endif //Initialise calculator teddsCalc.Initialize(); #if USE_TEDDS_CALC_IA_REF IFunctions functions = teddsCalc.Functions; #else dynamic functions = teddsCalc.Functions; #endif //Set inputs functions.SetVar("Height", height, heightUnits); functions.SetVar("Length", length, lengthUnits); functions.SetVar("Width", width, widthUnits); //Calculate volume functions.SetVarExpr("Volume", "Height * Length * Width"); //Get volume double volume = functions.GetVar("Volume").ToDouble(volumeUnits); //Close Tedds functions = null; teddsCalc = null; GC.Collect(); return(volume); }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { EquidistantIntervalsAttributeFunctionsI result = new EquidistantIntervalsAttributeFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { MutualInformationNormalizedFunctionsI result = new MutualInformationNormalizedFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public bool FSelect(IFunctions Name) { lock(WriteLock) { if(IFunctionsClass.ServerList[_servername].Functions.ContainsKey(Name.ToString().ToLower())) return IFunctionsClass.ServerList[_servername].Functions[Name.ToString().ToLower()] == SchumixBase.On; return false; } }
internal ClientSessionBuilder(FasterKV <Key, Value> fasterKV, IFunctions <Key, Value, Input, Output, Context> functions) { _fasterKV = fasterKV; _functions = functions; }
public AccountController(IFunctions Functions) { uiw = new UnitOfWork(); this.Functions = Functions; //ServicePointManager.ServerCertificateValidationCallback += (o, c, ch, er) => true; }
public HomeController(IFunctions Functions) { uiw = new UnitOfWork(); this.Functions = Functions; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { SDKLTaskFunctionsI result = new SDKLTaskFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { BooleanPartialCedentSettingFunctionsI result = new BooleanPartialCedentSettingFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { LiteralSettingFunctionsI result = new LiteralSettingFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { InformationDependencyFunctionsI result = new InformationDependencyFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { DoubleCriticalImplicationFunctionsI result = new DoubleCriticalImplicationFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { ConditionalEntropyFunctionsI result = new ConditionalEntropyFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { EachValueOneCategoryAttributeFunctionsI result = new EachValueOneCategoryAttributeFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { EquivalenceClassFunctionsI result = new EquivalenceClassFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { GeometricAverageFunctionsI result = new GeometricAverageFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { DiscreteOrdinaryVariationFunctionsI result = new DiscreteOrdinaryVariationFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { StandardDeviationFunctionsI result = new StandardDeviationFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { VariationRatioFunctionsI result = new VariationRatioFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
/// <summary> /// Creates <see cref="T:Ice.Object"/> implementing Ice interface of /// the box module i.e. box`s functions declared in slice design. /// </summary> /// <param name="boxModule">Box module, to which created functions /// will belong to.</param> /// <param name="iceObject">An out parameter returning <see cref="T:Ice.Object"/> /// implementing box`s "ice" functions. This value is same as value /// of <c>functions</c>.</param> /// <param name="functions">An out parameter returning <see cref="T:Ice.Object"/> /// implementing box`s "ice" functions. This value is same as value /// of <c>iceObject</c>.</param> /// <example> /// Please see an example for <see cref="T:Ferda.Modules.Boxes.IBoxInfo">IBoxInfo`s</see> /// <see cref="M:Ferda.Modules.Boxes.IBoxInfo.CreateFunctions(Ferda.Modules.BoxModuleI,Ice.Object,Ferda.Modules.IFunctions)"/>. /// </example> /// <remarks> /// Each instance of the box module has its own functions object but /// class implementing <see cref="T:Ferda.Modules.Boxes.IBoxInfo"> /// this interface</see> is shared by all instances of the box modules /// of the same type <see cref="P:Ferda.Modules.Boxes.IBoxInfo.Identifier"/> /// </remarks> public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { BodyMassIndexFunctionsI result = new BodyMassIndexFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
/// <summary> /// Helper method to specify callback function instance along with Input, Output and Context types /// </summary> /// <typeparam name="Input"></typeparam> /// <typeparam name="Output"></typeparam> /// <typeparam name="Context"></typeparam> /// <returns></returns> public ClientSessionBuilder <Input, Output, Context> For <Input, Output, Context>(IFunctions <Key, Value, Input, Output, Context> functions) { return(new ClientSessionBuilder <Input, Output, Context>(this, functions)); }
public StudentsController(IFunctions Functions) { uiw = new UnitOfWork(); this.Functions = Functions; }
/// <summary> /// Start a new client session with FASTER. /// For performance reasons, please use FasterKV<Key, Value>.For(functions).NewSession<Functions>(...) instead of this overload. /// </summary> /// <param name="functions">Callback functions</param> /// <param name="sessionId">ID/name of session (auto-generated if not provided)</param> /// <param name="threadAffinitized">For advanced users. Specifies whether session holds the thread epoch across calls. Do not use with async code. /// Ensure thread calls session Refresh periodically to move the system epoch forward.</param> /// <param name="sessionVariableLengthStructSettings">Session-specific variable-length struct settings</param> /// <returns>Session instance</returns> public ClientSession <Key, Value, Input, Output, Context, IFunctions <Key, Value, Input, Output, Context> > NewSession <Input, Output, Context>(IFunctions <Key, Value, Input, Output, Context> functions, string sessionId = null, bool threadAffinitized = false, SessionVariableLengthStructSettings <Value, Input> sessionVariableLengthStructSettings = null) { return(NewSession <Input, Output, Context, IFunctions <Key, Value, Input, Output, Context> >(functions, sessionId, threadAffinitized, sessionVariableLengthStructSettings)); }
/// <summary> /// 构造函数 /// </summary> public Functions() : base() { base.Init(this.GetType().FullName, System.Reflection.Assembly.GetExecutingAssembly().GetName().Name); baseDal.OnOperationLog += new OperationLogEventHandler(OperationLog.OnOperationLog);//如果需要记录操作日志,则实现这个事件 functionDal = baseDal as IFunctions; }
/// <summary> /// Resume (continue) prior client session with FASTER; used during recovery from failure. /// For performance reasons this overload is not recommended if functions is value type (struct). /// </summary> /// <param name="functions">Callback functions</param> /// <param name="sessionId">ID/name of previous session to resume</param> /// <param name="commitPoint">Prior commit point of durability for session</param> /// <param name="threadAffinitized">For advanced users. Specifies whether session holds the thread epoch across calls. Do not use with async code. /// Ensure thread calls session Refresh periodically to move the system epoch forward.</param> /// <param name="sessionVariableLengthStructSettings">Session-specific variable-length struct settings</param> /// <returns>Session instance</returns> public ClientSession <Key, Value, Input, Output, Context, IFunctions <Key, Value, Input, Output, Context> > ResumeSession <Input, Output, Context>(IFunctions <Key, Value, Input, Output, Context> functions, string sessionId, out CommitPoint commitPoint, bool threadAffinitized = false, SessionVariableLengthStructSettings <Value, Input> sessionVariableLengthStructSettings = null) { return(ResumeSession <Input, Output, Context, IFunctions <Key, Value, Input, Output, Context> >(functions, sessionId, out commitPoint, threadAffinitized, sessionVariableLengthStructSettings)); }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { AboveAverageImplicationFunctionsI result = new AboveAverageImplicationFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
/// <summary> /// Creates <see cref="T:Ice.Object"/> implementing Ice interface of /// the box module i.e. box`s functions declared in slice design. /// </summary> /// <param name="boxModule">Box module, to which created functions /// will belong to.</param> /// <param name="iceObject">An out parameter returning <see cref="T:Ice.Object"/> /// implementing box`s "ice" functions. This value is same as value /// of <c>functions</c>.</param> /// <param name="functions">An out parameter returning <see cref="T:Ice.Object"/> /// implementing box`s "ice" functions. This value is same as value /// of <c>iceObject</c>.</param> /// <example> /// Please see an example for <see cref="T:Ferda.Modules.Boxes.IBoxInfo">IBoxInfo`s</see> /// <see cref="M:Ferda.Modules.Boxes.IBoxInfo.CreateFunctions(Ferda.Modules.BoxModuleI,Ice.Object,Ferda.Modules.IFunctions)"/>. /// </example> /// <remarks> /// Each instance of the box module has its own functions object but /// class implementing <see cref="T:Ferda.Modules.Boxes.IBoxInfo"> /// this interface</see> is shared by all instances of the box modules /// of the same type <see cref="P:Ferda.Modules.Boxes.IBoxInfo.Identifier"/> /// </remarks> public abstract void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions);
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { ChiSquaredFunctionsI result = new ChiSquaredFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public ToJsCodeFactory( IMonad <string> monad, IFunctions <string> functions = null) : base(monad, functions) { }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { FunctionSumOfRowsFunctionsI result = new FunctionSumOfRowsFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }
public MaybeExpressionFactory( IMonad <Maybe <object> > monad, IFunctions <Maybe <object> > functions = null) : base(monad, functions ?? new DefaultFunctions <Maybe <object> >()) { }
public override void CreateFunctions(BoxModuleI boxModule, out Ice.Object iceObject, out IFunctions functions) { DataMatrixFunctionsI result = new DataMatrixFunctionsI(); iceObject = (Ice.Object)result; functions = (IFunctions)result; }