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
