/// <summary>
/// Authenticates the specified connection.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="collection">The collection.</param>
/// <param name="username">The username.</param>
/// <param name="nonce">The nonce.</param>
/// <param name="key">The key.</param>
/// <returns></returns>
public static bool authenticate(this IDBConnection connection, IDBCollection collection, string username, string nonce, SecureString key)
{
DBQuery cmd = BuildQuery_authenticate(username, nonce, key);
IDocument result = connection.Call<Document>(new Query(new DBCursorOptions(collection, selector: cmd, limit: 1))).Documents.FirstOrDefault();
DBError err;
return !result.WasError(out err);
}
public static void LoadPropertyValue(this ILGenerator il, PropertyInfo property, LocalBuilder target) {
if (target.LocalType.IsValueType || target.LocalType.IsNullable()) {
il.LoadLocalAddress(target);
il.Call(property.GetGetMethod());
} else {
il.LoadLocal(target);
il.CallVirt(property.GetGetMethod());
}
}
public static string asString(this AndroidJavaObject obj)
{
using (var stringObj = obj.Call<AndroidJavaObject>("toString")) {
using (
var bytesObj = stringObj.Call<AndroidJavaObject>("getBytes", "UTF8")
) {
var bytes = bytesObj.asBytes();
return bytes == null
? null : System.Text.Encoding.UTF8.GetString(bytes);
}
}
}
public static object[] SafeCall(this NLua.LuaFunction func, params object[] param)
{
try
{
return func.Call(param);
}
catch (NLua.Exceptions.LuaScriptException e)
{
Msg("[Error] " + e.Message);
return null;
}
}
/// <summary>
/// Calls a method on a java object while handling null return values.
/// Sadly, it appears that calling a method that returns a null Object in Java so we work
/// around this by catching null pointer exceptions a checking for the word "null".
/// </summary>
internal static AndroidJavaObject NullSafeCall(this AndroidJavaObject target,
string methodName, params object[] args) {
try {
return target.Call<AndroidJavaObject>(methodName, args);
} catch (Exception ex) {
if (ex.Message.Contains("null")) {
// expected -- means method returned null
return null;
} else {
GooglePlayGames.OurUtils.Logger.w("CallObjectMethod exception: " + ex);
return null;
}
}
}
/// <summary>
/// Queries a solver for a goal
/// </summary>
public static IQueryResult Query(this ISolver solver, ILiteral goal)
{
// Result is false for something without a key
if (goal.UnificationKey == null)
{
return new BasicQueryResult(false, new EmptyBinding(null));
}
// Compile the query
var unifier = new SimpleUnifier();
var assignments = new PredicateAssignmentList();
// Assume we have a basic predicate
foreach (var arg in goal.Dependencies)
{
assignments.AddArgument(arg);
}
// Run through the unifier
var freeVariableNames = unifier.QueryUnifier.Bind(assignments.Assignments);
var freeVariables = freeVariableNames.Select(variable => unifier.GetVariableLocation(variable).Dereference());
unifier.QueryUnifier.Compile(assignments.Assignments);
// Call via the solver
var moveNext = solver.Call(goal.UnificationKey, unifier.GetArgumentVariables(assignments.CountArguments()));
Func<IQueryResult> nextResult = () =>
{
// Update the variables to the next result
var succeeded = moveNext();
// Nothing to do if we didn't succeed
if (!succeeded)
{
return new BasicQueryResult(false, new EmptyBinding(null));
}
// Bind the variables
var variableValues = freeVariables
.Select(varRef => varRef.Freeze())
.Zip(freeVariableNames, (value, name) => new { Value = value, Name = name }).ToArray();
var binding = new BasicBinding(null, variableValues.ToDictionary(val => val.Name, val => val.Value));
// Return the result
return new BasicQueryResult(true, binding);
};
// Chain to produce the final result
return new ChainedResult(nextResult(), () => Task.FromResult(nextResult()));
}
/// <summary>
/// Emits a call to output a textual diagnostic message.
/// </summary>
/// <param name="builder">algorithm builder</param>
/// <param name="args">output arguments</param>
public static void ReportLine(this IAlgorithmBuilder builder, params object[] args)
{
var arg = Expression.Concat(args.Select(_ => ToExpression(_)).ToArray());
builder.Call(IntrinsicFunctions.ReportLine(arg), arg);
}
/// <summary>
/// Gets a nonce for subsequent communication
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="cmdCollection">The CMD collection.</param>
/// <returns></returns>
public static string nonce(this IDBConnection connection, IDBCollection cmdCollection)
{
IDocument result = connection.Call<Document>(new Query(new DBCursorOptions(cmdCollection, selector: _getnonce, limit: 1))).Documents.FirstOrDefault();
result.ThrowIfResponseNotOK("unable to get nonce value for authentication");
return result.GetAsString("nonce");
}
public static CodeExpression Call(
this CodeExpression targetObject,
String methodName
)
=> targetObject.Call(methodName, new Type[0], new CodeExpression[0]);
/// <summary>
/// ラムダ式などで<see cref="Predicate{T}"/>相当のオブジェクトが渡されたものとしてCallします。
/// </summary>
/// <param name="obj">対象</param>
/// <param name="ctx">現在の<see cref="KecaknoahContext"/></param>
/// <param name="tr">渡すオブジェクト</param>
/// <returns></returns>
public static bool CallAsPredicate(this KecaknoahObject obj, KecaknoahContext ctx, KecaknoahObject tr) => obj.Call(ctx, new[] { tr }).ReturningObject.ToBoolean();
public static Expression Call(this Function f, params Expression[] exprs)
{
return f.Call(exprs.AsEnumerable());
}
public static CodeExpression Call(
this CodeExpression targetObject,
String methodName,
params CodeExpression[] parameters
)
=> targetObject.Call(methodName, new Type[0], parameters);
public static Expression Call(this Function f, Expression expr)
{
return f.Call(expr.AsEnumerable());
}
public static CodeIterationStatement ForEach(this CodeParameterDeclarationExpression enumerableVar, Type itemType, out CodeVariableDeclarationStatement item)
{
//IEnumerator<itemType> iter = enumerableVar.GetEnumerator()
var iter = "iter".DeclareGenericVar(itemType, enumerableVar.Call("GetEnumerator"), typeof(IEnumerator<>));
var iterStatement = new CodeIterationStatement {
InitStatement = iter,
TestExpression = iter.Call("MoveNext"),
IncrementStatement = new CodeSnippetStatement(""),
};
item = itemType.DeclareVar("item", iter.RefProperty("Current"));
iterStatement.Statements.Add(item);
return iterStatement;
}
public static CodeExpression Call(
this CodeExpression targetObject,
String methodName,
params Type[] typeParameters
)
=> targetObject.Call(methodName, typeParameters, new CodeExpression[0]);
/// <summary>
/// Emit Equality Compare for 2 arguments in top of stack
/// </summary>
/// <param name="il"></param>
/// <param name="argType"></param>
/// <returns></returns>
public static ILGenerator IsEquals(this ILGenerator il, Type argType)
{
if (argType.IsPrimitive)
{
return il.Ceq();
}
var nulType = Nullable.GetUnderlyingType(argType);
if (nulType != null)
{
var miGetValue = argType.GetProperty("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).GetGetMethod();
var miHasValue = argType.GetProperty("HasValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).GetGetMethod();
var locVar1 = il.DeclareLocal(argType);
var locVar2 = il.DeclareLocal(argType);
var lblHasValues = il.DefineLabel();
var lblExit = il.DefineLabel();
il
.Stloc(locVar2)
.Stloc(locVar1)
.Ldloca(locVar1)
.Call(miHasValue)
.Ldloca(locVar2)
.Call(miHasValue)
.Add()
.Dup()
.Ldc_I4(2)
.Beq(lblHasValues)
.Ldtrue()
.Xor()
.Br(lblExit)
.Label(lblHasValues)
.Pop()
.Ldloca(locVar1)
.Call(miGetValue)
.Ldloca(locVar2)
.Call(miGetValue)
.IsEquals(nulType)
.Label(lblExit);
return il;
}
var eqMethod = argType.GetMethod("op_Equality",
BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly,
null, new Type[] { argType, argType }, null);
if (eqMethod != null)
{
return il.Call(eqMethod);
}
var eqType = typeof(IEquatable<>).MakeGenericType(argType);
var lblEnd = il.DefineLabel();
if (!argType.IsValueType)
{
if (eqType.IsAssignableFrom(argType))
{
var lblHasValue1 = il.DefineLabel();
var locVar2 = il.DeclareLocal(argType);
il
.Stloc(locVar2)
.Dup()
.Brtrue(lblHasValue1)
.Ldloc(locVar2) // if arg1 == 0
.Ceq() // Сравниваем refernces
.Br(lblEnd)
.Label(lblHasValue1)
.Ldloc(locVar2)
.Callvirt(eqType.GetMethod("Equals"));
}
else
{
il.Ceq();
}
}
else
{
if (eqType.IsAssignableFrom(argType))
{
var var1 = il.DeclareLocal(argType);
il.Stloc(var1).Ldloca(var1);
il.Callvirt(eqType.GetMethod("Equals"));
}
}
il.MarkLabel(lblEnd);
return il;
}
/// <summary>
///
/// </summary>
/// <param name="il"></param>
/// <param name="source"></param>
/// <param name="destination"></param>
/// <returns></returns>
public static ILGenerator Convert(this ILGenerator il, Type source, Type destination)
{
if (source == null) throw new ArgumentNullException("source");
if (destination == null) throw new ArgumentNullException("destination");
if (source == destination) return il;
if (source == typeof(Object) && destination.IsValueType) return il.Unbox_Any(destination);
if (source.IsValueType && destination == typeof(Object)) return il.Box(destination);
// if (source.IsAssignableFrom(destination)) return this;
// --> it doesn't work for int? -> int, cause int is assignable from int?
var converter = LookUpConverter(source, destination);
if (converter != null) // not so beauty, but it's enough for internal code
{
// todo. implement invariant culture here
if (converter is ConstructorInfo) return il.Newobj((ConstructorInfo)converter);
// note the ClassCastException expected below in near future :)
return converter.IsVirtual ? il.Callvirt((MethodInfo)converter) : il.Call((MethodInfo)converter);
}
Func<ILGenerator, ILGenerator> emitter;
if (CanGenerateConverter(source, destination, out emitter)) return emitter(il);
return il.Castclass(destination);
}
