public ForumCollection<Forum> GetForums(Boolean active) { ForumCollection<Forum> _coll = new ForumCollection<Forum>(this.ConnectionString); ArgumentsList _arg = new ArgumentsList(new ArgumentsListItem("Active", active.ToString())); _coll.LitePopulate(_arg, false, null); return _coll; }
} // func IndexSetExpression private static Expression InvokeExpression(Scope scope, Token tStart, Expression instance, InvokeResult result, ArgumentsList arguments, bool lParse) { MethodInfo mi; ConstantExpression constInstance = instance as ConstantExpression; LuaType t; if (constInstance != null && (t = constInstance.Value as LuaType) != null && t.Type != null) // we have a type, bind the ctor { var type = t.Type; var typeInfo = type.GetTypeInfo(); var ci = typeInfo.IsValueType && arguments.Count == 0 ? null : LuaEmit.FindMember(typeInfo.DeclaredConstructors.Where(c => c.IsPublic), arguments.CallInfo, arguments.Expressions, getExpressionTypeFunction, false); if (ci == null && !typeInfo.IsValueType) { throw ParseError(tStart, String.Format(Properties.Resources.rsMemberNotResolved, type.Name, "ctor")); } return(SafeExpression(() => LuaEmit.BindParameter(scope.Runtime, args => ci == null ? Expression.New(type) : Expression.New(ci, args), ci == null ? new ParameterInfo[0] : ci.GetParameters(), arguments.CallInfo, arguments.Expressions, getExpressionFunction, getExpressionTypeFunction, true), tStart)); } else if (LuaEmit.IsDynamicType(instance.Type)) { // fallback is a dynamic call return(EnsureInvokeResult(scope, tStart, DynamicExpression.Dynamic(scope.Runtime.GetInvokeBinder(arguments.CallInfo), typeof(object), new Expression[] { ConvertExpression(scope.Runtime, tStart, instance, typeof(object)) }.Concat( from c in arguments.Expressions select Lua.EnsureType(c, typeof(object)) ) ), result, instance, null )); } else if (typeof(Delegate).GetTypeInfo().IsAssignableFrom(instance.Type.GetTypeInfo()) && // test if the type is assignable from delegate (mi = instance.Type.GetRuntimeMethods().Where(c => !c.IsStatic && c.IsPublic && c.Name == "Invoke").FirstOrDefault()) != null) // Search the Invoke method for the arguments { return(EnsureInvokeResult(scope, tStart, SafeExpression(() => LuaEmit.BindParameter <Expression>( scope.Runtime, args => Expression.Invoke(instance, args), mi.GetParameters(), arguments.CallInfo, arguments.Expressions, getExpressionFunction, getExpressionTypeFunction, true), tStart), result, instance, null )); } else { throw ParseError(tStart, LuaEmitException.GetMessageText(LuaEmitException.InvokeNoDelegate, instance.Type.Name)); } } // func InvokeExpression
} // func InvokeExpression private static Expression InvokeMemberExpression(Scope scope, Token tStart, Expression instance, string sMember, InvokeResult result, ArgumentsList arguments) { if (LuaEmit.IsDynamicType(instance.Type)) { return EnsureInvokeResult(scope, tStart, DynamicExpression.Dynamic(scope.Runtime.GetInvokeMemberBinder(sMember, arguments.CallInfo), typeof(object), new Expression[] { ConvertExpression(scope.Runtime, tStart, instance, typeof(object)) }.Concat( from c in arguments.Expressions select Lua.EnsureType(c, typeof(object)) ).ToArray() ), result, instance, sMember ); } else { // look up the method MethodInfo method = LuaEmit.FindMethod( LuaType.GetType(instance.Type).GetInstanceMethods(sMember, false), arguments.CallInfo, arguments.Expressions, getExpressionTypeFunction, true); if (method != null) return EnsureInvokeResult(scope, tStart, SafeExpression(() => InvokeMemberExpressionBind(method, scope.Runtime, instance, arguments), tStart), result, instance, sMember); else return InvokeMemberExpressionDynamic(scope, tStart, instance, sMember, result, arguments); } } // func InvokeMemberExpression
public PrefixMemberInfo(Token position, Expression instance, string sMember, Expression[] indices, ArgumentsList arguments) { this.Position = position; this.Instance = instance; this.Member = sMember; this.Indices = indices; this.Arguments = arguments; }
public TimeOfDayCollection<TimeOfDay> GetTimeOfDays(Enums.enumStatuses status) { TimeOfDayCollection<TimeOfDay> _coll = new TimeOfDayCollection<TimeOfDay>(this.ConnectionString); ArgumentsList _arg = new ArgumentsList(new ArgumentsListItem("Status", Convert.ToInt32(status).ToString())); _coll.LitePopulate(_arg, false, null); return _coll; }
/// <summary> /// Serializes a navigational filtering arguments list into an XML file. /// </summary> /// <param name="writer">XMLWriter where the list of arguments is stored.</param> /// <param name="arguments">List of arguments to serialize.</param> /// <returns>Returns the XMLWriter with the list of arguments.</returns> public static XmlWriter Serialize(XmlWriter writer, ArgumentsList arguments) { if (arguments != null) { writer.WriteStartElement(DTD.Request.ServiceRequest.TagArguments); foreach (ArgumentInfo i in arguments) { XMLNavigationalFilteringArgumentInfoSerializer.Serialize(writer, i); } writer.WriteEndElement(); } return writer; }
protected override bool Handle(ArgumentsList args, OptionsList opts) { logger.Clear(); return(true); }
/// creates an Index Change event command /// </summary> /// <returns>newly created command.</returns> internal static IndexChangeEventCommand CreateIndexChangeCommand(string taskTag, int recId, ArgumentsList argList) { IndexChangeEventCommand cmd = new IndexChangeEventCommand { TaskTag = taskTag, ClientRecId = recId }; // 1 parameter : The new Key Index if (argList != null && argList.getSize() != 0) { try { var keyIndex = new NUM_TYPE(argList.getArgValue(0, StorageAttribute.NUMERIC, 0)); cmd.KeyIndex = keyIndex.NUM_2_LONG(); } catch (Exception) { cmd.KeyIndex = 0; } } return(cmd); }
public void HandleAttribute(string attribute, string valueStr) { switch (attribute) { case XMLConstants.MG_ATTR_TASKID: TaskTag = valueStr; break; case ConstInterface.MG_ATTR_HANDLERID: { int i = valueStr.IndexOf(","); string handlerId = i > -1 ? valueStr.Substring(i + 1) : valueStr; _handlerId = handlerId; } break; case ConstInterface.MG_ATTR_OBJECT: Obj = valueStr; break; case ConstInterface.MG_ATTR_MESSAGE: XmlParser.unescape(valueStr); break; case ConstInterface.MG_ATTR_HTML: _html = XmlParser.unescape(valueStr); break; case ConstInterface.MG_ATTR_MODAL: _isModal = (valueStr[0] == '1'); break; case ConstInterface.MG_ATTR_URL: _url = XmlParser.unescape(valueStr); break; case ConstInterface.MG_ATTR_SRCTASK: break; case XMLConstants.MG_ATTR_VALUE: _val = XmlParser.unescape(valueStr); break; case ConstInterface.MG_ATTR_CALLINGTASK: _callingTaskTag = valueStr; break; case ConstInterface.MG_ATTR_PATH_PARENT_TASK: _pathParentTaskTag = valueStr; break; case ConstInterface.MG_ATTR_ARGLIST: _varList = new ArgumentsList(); _varList.fillList(valueStr, (Task)MGDataTable.Instance.GetTaskByID(TaskTag)); break; case ConstInterface.MG_ATTR_TEXT: _text = XmlParser.unescape(valueStr); break; case ConstInterface.MG_ATTR_TITLE: _title = valueStr; break; case ConstInterface.MG_ATTR_IMAGE: _image = valueStr[0]; break; case ConstInterface.MG_ATTR_BUTTONS: _buttonsID = valueStr[0]; break; case ConstInterface.MG_ATTR_DEFAULT_BUTTON: _defaultButton = XmlParser.getInt(valueStr); break; case ConstInterface.MG_ATTR_RETURN_VAL: _returnValStr = valueStr; break; case ConstInterface.MG_ATTR_ERR_LOG_APPEND: _errLogAppend = XmlParser.getBoolean(valueStr); break; case ConstInterface.MG_ATTR_DISPLAY: _display = valueStr[0]; break; case ConstInterface.MG_ATTR_MODE: _mode = valueStr[0]; break; case ConstInterface.MG_ATTR_ACK: _sendAck = (XmlParser.getInt(valueStr) != 0); break; case ConstInterface.MG_ATTR_NULL: _isNull = (XmlParser.getInt(valueStr) == 1); break; case ConstInterface.MG_ATTR_PAR_ATTRS: _attr = (StorageAttribute)valueStr[0]; break; case ConstInterface.MG_ATTR_OLDID: _oldId = StrUtil.rtrim(valueStr); break; case ConstInterface.MG_ATTR_NEWID: _newId = StrUtil.rtrim(valueStr); break; case ConstInterface.MG_ATTR_TOP: XmlParser.getInt(valueStr); break; case ConstInterface.MG_ATTR_LEFT: XmlParser.getInt(valueStr); break; case ConstInterface.MG_ATTR_WIDTH: XmlParser.getInt(valueStr); break; case ConstInterface.MG_ATTR_HEIGHT: XmlParser.getInt(valueStr); break; case ConstInterface.MG_ATTR_LEN: _htmlLen = XmlParser.getInt(valueStr); break; case ConstInterface.MG_ATTR_ENCRYPT: _encryptXML = (XmlParser.getInt(valueStr) == 1); break; case ConstInterface.MG_ATTR_SCAN: _htmlScan = (XmlParser.getInt(valueStr) == 1); break; case ConstInterface.MG_ATTR_STANDALONE: _standalone = (XmlParser.getInt(valueStr) == 1); break; case ConstInterface.MG_ATTR_KEY: _key = valueStr; break; case XMLConstants.MG_ATTR_DITIDX: _ditIdx = XmlParser.getInt(valueStr); break; case ConstInterface.MG_ATTR_TRANS_OWNER: _transOwner = valueStr; break; case ConstInterface.MG_ATTR_SUBFORM_CTRL: _subformCtrlName = valueStr; break; // code to be used when RangeAdd is called on the server, with a local data field case ConstInterface.MG_ATTR_FIELD_INDEX: // temporary code! will be moved to a factory if (UserRange == null) { UserRange = new UserRange() { nullMin = true, nullMax = true } } ; UserRange.veeIdx = XmlParser.getInt(valueStr); break; case ConstInterface.MG_ATTR_MIN_VALUE: UserRange.min = valueStr; UserRange.nullMin = false; break; case ConstInterface.MG_ATTR_MAX_VALUE: UserRange.max = valueStr; UserRange.nullMax = false; break; // end of RangeAdd code default: Logger.Instance.WriteErrorToLog( "There is no such tag in Command class. Insert case to Command.initElements for " + attribute); break; } }
/// <inheritdoc/> public override int GetHashCode() => ArgumentsList.GetHashCodeOfList();
/// <summary> /// Gets a generic enumerator. /// </summary> /// <returns>A generic enumerator.</returns> public IEnumerator <ConstructionArgument> GetEnumerator() => ArgumentsList.GetEnumerator();
/// <summary> /// Recreates the arguments using a given mapping of loose objects. /// </summary> /// <param name="mapping">The mapping of the loose objects.</param> /// <returns>The remapped arguments.</returns> public Arguments Remap(IReadOnlyDictionary <LooseConfigurationObject, LooseConfigurationObject> mapping) { // Remap individual arguments using their remap method return(new Arguments(ArgumentsList.Select(argument => argument.Remap(mapping)).ToList())); }
protected Command(string keyword, string description) : base(keyword, description) { RequiredArguments = new ArgumentsList(); OptionalArguments = new ArgumentsList(); }
} // func InvokeMemberExpressionBind private static Expression InvokeMemberExpressionDynamic(Scope scope, Token tStart, Expression instance, string sMember, InvokeResult result, ArgumentsList arguments) { return EnsureInvokeResult(scope, tStart, DynamicExpression.Dynamic(scope.Runtime.GetInvokeMemberBinder(sMember, arguments.CallInfo), typeof(object), new Expression[] { ConvertExpression(scope.Runtime, tStart, instance, typeof(object)) }.Concat(from a in arguments.Expressions select Lua.EnsureType(a, typeof(object))).ToArray() ), result, instance, sMember ); } // func InvokeMemberExpressionDynamic
} // func InvokeMemberExpression private static Expression InvokeMemberExpressionBind(MethodInfo method, Lua runtime, Expression instance, ArgumentsList arguments) { if (method.IsStatic) { return LuaEmit.BindParameter(runtime, args => Expression.Call(null, method, args), method.GetParameters(), arguments.CallInfo, new Expression[] { instance }.Concat( from a in arguments.Expressions select Lua.EnsureType(a, typeof(object)) ).ToArray(), getExpressionFunction, getExpressionTypeFunction, true); } else { return LuaEmit.BindParameter(runtime, args => Expression.Call(instance, method, args), method.GetParameters(), arguments.CallInfo, arguments.Expressions, getExpressionFunction, getExpressionTypeFunction, true); } } // func InvokeMemberExpressionBind
} // func InvokeExpression private static Expression InvokeMemberExpression(Scope scope, Token tStart, Expression instance, string memberName, InvokeResult result, ArgumentsList arguments) { if (LuaEmit.IsDynamicType(instance.Type) || arguments.Expressions.Any(c => LuaEmit.IsDynamicType(c.Type))) { var dynamicArguments = new Expression[arguments.Count + 1]; // first argument is the instance dynamicArguments[0] = ConvertObjectExpression(scope.Runtime, tStart, instance, false); if (arguments.Count > 0) { // single object for (var i = 0; i < arguments.Count - 1; i++) { dynamicArguments[i + 1] = ConvertObjectExpression(scope.Runtime, tStart, arguments.Expressions[i], false); } // last argument is different if (arguments.CallInfo.ArgumentNames.Count > 0) { dynamicArguments[dynamicArguments.Length - 1] = ConvertObjectExpression(scope.Runtime, tStart, arguments.Expressions[arguments.Count - 1], false); } else { dynamicArguments[dynamicArguments.Length - 1] = Lua.EnsureType(arguments.Expressions[arguments.Count - 1], typeof(object)); } } return(EnsureInvokeResult(scope, tStart, DynamicExpression.Dynamic(scope.Runtime.GetInvokeMemberBinder(memberName, arguments.CallInfo), typeof(object), dynamicArguments), result, instance, memberName )); } else { return(EnsureInvokeResult(scope, tStart, SafeExpression(() => { Expression expr; if (!LuaEmit.TryInvokeMember <Expression>(scope.Runtime, LuaType.GetType(instance.Type), instance, arguments.CallInfo, arguments.Expressions, memberName, false, e => e, e => e.Type, true, out expr)) { throw new LuaEmitException(LuaEmitException.MemberNotFound, instance.Type, memberName); } return expr; }, tStart), result, instance, memberName )); } } // func InvokeMemberExpression
/// <summary> /// creates only a real refresh event command /// </summary> /// <returns>newly created command.</returns> internal static RefreshEventCommand CreateRealRefreshCommand(String taskId, int magicEvent, int currentRow, ArgumentsList argList, int currentRecId) { RefreshEventCommand cmd = new RefreshEventCommand(magicEvent) { TaskTag = taskId, RefreshMode = ViewRefreshMode.CurrentLocation, KeepUserSort = false, ClientRecId = currentRecId, CurrentRecordRow = currentRow }; if (argList != null && argList.getSize() != 0) { try { var refreshMode = new NUM_TYPE(argList.getArgValue(0, StorageAttribute.NUMERIC, 0)); cmd.RefreshMode = (ViewRefreshMode)refreshMode.NUM_2_LONG() + 1; } catch (Exception) { cmd.RefreshMode = ViewRefreshMode.CurrentLocation; } if (argList.getSize() > 1) { try { cmd.KeepUserSort = (argList.getArgValue(1, StorageAttribute.BOOLEAN, 0) == "1"); } catch (Exception) { cmd.KeepUserSort = false; } } } return(cmd); }
public ArgumentsList CreateArgumentList(string sortExpression, Int32 maximumRows, Int32 startRowIndex, String cultureValue) { ArgumentsList _arg = new ArgumentsList(); _arg.Add(new ArgumentsListItem("Sort", sortExpression)); _arg.Add(new ArgumentsListItem("PageSize", maximumRows.ToString())); _arg.Add(new ArgumentsListItem("PageNumber", startRowIndex.ToString())); _arg.Add(new ArgumentsListItem("CultureName", cultureValue)); return _arg; }
/// <summary> /// Get Themes by arglist /// </summary> /// <param name="status"></param> /// <returns></returns> public SiteThemesCollection<SiteThemes> GetThemes(Enums.enumStatuses status) { SiteThemesCollection<SiteThemes> _coll = new SiteThemesCollection<SiteThemes>(this.ConnectionString); ArgumentsList _arg = new ArgumentsList(new ArgumentsListItem("Status", Convert.ToInt32(status).ToString())); _coll.LitePopulate(_arg, false, null); return _coll; }
public DataTable GetTopics(ArgumentsList argList) { return m_dbObject.RetriveTopicsByArgList(argList.ToXml(), this.ConnectionString); }
/// <summary> /// set the arguments on the task parameters /// </summary> /// <param name="task"></param> /// <param name="args"></param> internal abstract void CopyArguments(Task task, ArgumentsList args);
public Int32 GetTopicTotal(ArgumentsList argList) { DataTable _dt = m_dbObject.RetriveTotalTopicsByArgList(argList.ToXml(), this.ConnectionString); if (_dt.Rows.Count > 0) { return Convert.ToInt32(_dt.Rows[0][0]); } return 0; }
/// <summary> /// Get Users /// </summary> /// <param name="status"></param> /// <returns></returns> public UsersCollection<TopRockUser> GetUsers(enumStatuses status) { UsersCollection<TopRockUser> _coll = new UsersCollection<TopRockUser>(this.ConnectionString); ArgumentsList _arg = new ArgumentsList(new ArgumentsListItem("Status", Convert.ToInt32(status).ToString())); _coll.LitePopulate(_arg,false, null); return _coll; }
protected abstract bool Handle(ArgumentsList args, OptionsList opts);
/// <summary> /// set the arguments on the task parameters /// </summary> /// <param name="task"></param> /// <param name="args"></param> internal override void CopyArguments(Task task, ArgumentsList args) { task.CopyArguments(args); }
/// <summary> /// Initializes a new instance of the <see cref="L20n.FTL.AST.CallExpression"/> class. /// </summary> public CallExpression(StringPrimitive builtin, ArgumentsList arguments) { m_Builtin = builtin; m_Arguments = arguments; }
private static ArgumentsList ParseArgumentList(Scope scope, LuaLexer code) { FetchToken(LuaToken.BracketOpen, code); // exprArgumentList := '(' [ exprArg { , exprArg } ] ')' var argumentsList = new ArgumentsList(); while (code.Current.Typ != LuaToken.BracketClose) { Token tName = null; if (code.LookAhead.Typ == LuaToken.Assign) // named argument { tName = FetchToken(LuaToken.Identifier, code); code.Next(); // equal } // parse the expression var tFirst = code.Current; var expr = ParseExpression(scope, code, InvokeResult.LuaResult, scope.EmitExpressionDebug); if (tName == null) argumentsList.AddPositionalArgument(tFirst, expr); else argumentsList.AddNamedArgument(tName, expr); // optinal comma FetchToken(LuaToken.Comma, code, true); } code.Next(); return argumentsList; }
} // func IndexSetExpression private static Expression InvokeExpression(Scope scope, Token tStart, Expression instance, InvokeResult result, ArgumentsList arguments, bool lParse) { MethodInfo mi; ConstantExpression constInstance = instance as ConstantExpression; LuaType t; if (constInstance != null && (t = constInstance.Value as LuaType) != null && t.Type != null) // we have a type, bind the ctor { var type = t.Type; var typeInfo = type.GetTypeInfo(); var ci = typeInfo.IsValueType && arguments.Count == 0 ? null : LuaEmit.FindMember(typeInfo.DeclaredConstructors.Where(c => c.IsPublic), arguments.CallInfo, arguments.Expressions, getExpressionTypeFunction, false); if (ci == null && !typeInfo.IsValueType) throw ParseError(tStart, String.Format(Properties.Resources.rsMemberNotResolved, type.Name, "ctor")); return SafeExpression(() => LuaEmit.BindParameter(scope.Runtime, args => ci == null ? Expression.New(type) : Expression.New(ci, args), ci == null ? new ParameterInfo[0] : ci.GetParameters(), arguments.CallInfo, arguments.Expressions, getExpressionFunction, getExpressionTypeFunction, true), tStart); } else if (LuaEmit.IsDynamicType(instance.Type)) { // fallback is a dynamic call return EnsureInvokeResult(scope, tStart, DynamicExpression.Dynamic(scope.Runtime.GetInvokeBinder(arguments.CallInfo), typeof(object), new Expression[] { ConvertExpression(scope.Runtime, tStart, instance, typeof(object)) }.Concat( from c in arguments.Expressions select Lua.EnsureType(c, typeof(object)) ) ), result, instance, null ); } else if (typeof(Delegate).GetTypeInfo().IsAssignableFrom(instance.Type.GetTypeInfo()) && // test if the type is assignable from delegate (mi = instance.Type.GetRuntimeMethods().Where(c => !c.IsStatic && c.IsPublic && c.Name == "Invoke").FirstOrDefault()) != null) // Search the Invoke method for the arguments { return EnsureInvokeResult(scope, tStart, SafeExpression(() => LuaEmit.BindParameter<Expression>( scope.Runtime, args => Expression.Invoke(instance, args), mi.GetParameters(), arguments.CallInfo, arguments.Expressions, getExpressionFunction, getExpressionTypeFunction, true), tStart), result, instance, null ); } else throw ParseError(tStart, LuaEmitException.GetMessageText(LuaEmitException.InvokeNoDelegate, instance.Type.Name)); } // func InvokeExpression