public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { if (binder.Operation != ExpressionType.OnesComplement) { return base.TryUnaryOperation(binder, out result); } result = get_xml_value(); return true; }
internal override bool UnaryOperation(UnaryOperationBinder binder, out Any result) { switch (binder.Operation) { case ExpressionType.IsTrue: result = Value.Length > 0 ? Bool.True : Bool.False; return true; } return base.UnaryOperation(binder, out result); }
internal override bool UnaryOperation(UnaryOperationBinder binder, out Any result) { switch (binder.Operation) { case ExpressionType.IsTrue: result = ((int)Value) != 0 ? Bool.True : Bool.False; return true; case ExpressionType.Negate: result = new Number(-Value); return true; } return base.UnaryOperation(binder, out result); }
public override bool TryUnaryOperation(UnaryOperationBinder binder, out Object result) { int r; IntPtr res; switch (binder.Operation) { case ExpressionType.Negate: res = Runtime.PyNumber_Negative(this.obj); break; case ExpressionType.UnaryPlus: res = Runtime.PyNumber_Positive(this.obj); break; case ExpressionType.OnesComplement: res = Runtime.PyNumber_Invert(this.obj); break; case ExpressionType.Not: r = Runtime.PyObject_Not(this.obj); result = r == 1; return r != -1; case ExpressionType.IsFalse: r = Runtime.PyObject_IsTrue(this.obj); result = r == 0; return r != -1; case ExpressionType.IsTrue: r = Runtime.PyObject_IsTrue(this.obj); result = r == 1; return r != -1; case ExpressionType.Decrement: case ExpressionType.Increment: default: result = null; return false; } result = new PyObject(res); return true; }
/// <summary> /// Override on DynamicObject /// </summary> /// <param name="binder"></param> /// <param name="result"></param> /// <returns></returns> public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { result = new Mimic(); return true; }
public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { if(binder.Operation == System.Linq.Expressions.ExpressionType.IsTrue) { result = this; return true; } throw new NotImplementedException(); }
public override Boolean TryUnaryOperation(UnaryOperationBinder binder, out Object result) { result = null; Boolean boolResult; switch (binder.Operation) { case ExpressionType.IsTrue: { if (TypeConversion.TryConvertTo(_target, out boolResult)) { result = boolResult; return true; } return false; } } throw new NotImplementedException(String.Format("TryUnaryOperation op={0}", binder.Operation)); }
/// <summary> /// Performs the binding of the dynamic unary operation. /// </summary> /// <param name="binder">An instance of the <see cref="UnaryOperationBinder"/> that represents the details of the dynamic operation.</param> /// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns> public virtual DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { ContractUtils.RequiresNotNull(binder, "binder"); return binder.FallbackUnaryOperation(this); }
public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { return scriptItem.PostProcessBindResult(metaDynamic.BindUnaryOperation(binder)); }
/*!*/ public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder/*!*/ binder) { return InteropBinder.UnaryOperation.Bind(CreateMetaContext(), binder, this, binder.FallbackUnaryOperation); }
public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { throw new NotImplementedException(); }
public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { return BuildCallSelf(_unaryMethod, Expression.Constant(binder.Operation)); }
public virtual new bool TryUnaryOperation(UnaryOperationBinder binder, out Object result) { result = default(Object); return(default(bool)); }
public override bool TryUnaryOperation( UnaryOperationBinder binder, out object result ) { if ( TryUnaryOperationMissing == null ) { result = null; return false; } return TryUnaryOperationMissing( binder, out result ); }
public virtual bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { result = null; return(false); }
/// <summary> /// Performs the binding of the dynamic unary operation. /// </summary> /// <param name="binder">An instance of the <see cref="UnaryOperationBinder"/> that represents the details of the dynamic operation.</param> /// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns> public virtual DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { ContractUtils.RequiresNotNull(binder, nameof(binder)); return(binder.FallbackUnaryOperation(this)); }
public virtual DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { throw new NotImplementedException(); }
// // Summary: // Provides implementation for unary operations. Classes derived from the System.Dynamic.DynamicObject // class can override this method to specify dynamic behavior for operations such // as negation, increment, or decrement. // // Parameters: // binder: // Provides information about the unary operation. The binder.Operation property // returns an System.Linq.Expressions.ExpressionType object. For example, for the // negativeNumber = -number statement, where number is derived from the DynamicObject // class, binder.Operation returns "Negate". // // result: // The result of the unary operation. // // Returns: // true if the operation is successful; otherwise, false. If this method returns // false, the run-time binder of the language determines the behavior. (In most // cases, a language-specific run-time exception is thrown.) public virtual bool TryUnaryOperation(UnaryOperationBinder binder, out object result);
public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { if (binder.Operation != ExpressionType.OnesComplement) { return base.TryUnaryOperation(binder, out result); } result = (_nodeType == NodeType.Element) ? InternalContent : InternalValue; return true; }
public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { if (binder.Operation == ExpressionType.IsFalse || binder.Operation == ExpressionType.IsTrue) { result = false; return true; } result = new DynamicExpressionBuilder(Expression.MakeUnary(binder.Operation, Expression, binder.ReturnType)); return true; }
public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { MessageBox.Show("Here"); return base.TryUnaryOperation(binder, out result); }
public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { var eng = GetEngine(); switch (binder.Operation) { case ExpressionType.IsFalse: result = !IsTruthy; return true; case ExpressionType.IsTrue: result = IsTruthy; return true; case ExpressionType.Negate: case ExpressionType.NegateChecked: switch (Type) { case JavaScriptValueType.Number: double n = eng.Converter.ToDouble(this); result = -n; return true; case JavaScriptValueType.Boolean: if (IsTruthy) result = -1; else result = -0; return true; // TODO // case JavaScriptValueType.String: } result = double.NaN; return true; case ExpressionType.UnaryPlus: switch (Type) { case JavaScriptValueType.Number: result = eng.Converter.ToDouble(this); return true; case JavaScriptValueType.Boolean: if (IsTruthy) result = 1; else result = 0; return true; } result = double.NaN; return true; } return base.TryUnaryOperation(binder, out result); }
public virtual new System.Dynamic.DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { Contract.Requires(binder != null); return default(System.Dynamic.DynamicMetaObject); }
public override Boolean TryUnaryOperation(UnaryOperationBinder binder, out Object result) { throw new NotImplementedException("JsValue.TryUnaryOperation"); }
public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { return binder.FallbackUnaryOperation(this); }
public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { /* * Effectively returns the following code: * { * var thisEvaled = (JsonObject)<Expression>; * object res; * ReturnType finalResult; * if(!Value.InnerTryUnaryOperation(ExpressionType, ReturnType, out res)) * { * throw new InvalidCastException("Unable to get dynamic member <MemberName> of type <ReturnType> from ["+thisRef+"]"); * } * finalResult = (ReturnType)res; * } */ var thisRef = Expression.Type != typeof(JsonObject) ? Expression.Convert(Expression, typeof(JsonObject)) : Expression; var thisEvaled = ThisEvaled; var thisAssigned = Expression.Assign(thisEvaled, thisRef); var finalResult = Expression.Variable(binder.ReturnType); var res = Res; var tryUnaryOperationCall = Expression.Call(thisEvaled, InnerTryUnaryOperation, Expression.Constant(binder.Operation), Expression.Constant(binder.ReturnType), res); var throwExc = Expression.Throw( Expression.New( InvalidCastExceptionCons, Expression.Call( StringConcat, Expression.Constant("Unable to perform dynamic unary operation [" + binder.Operation + "] of type [" + binder.ReturnType.FullName + "] from ["), thisEvaled, CloseSquareBracket ) ) ); var notIf = Expression.IfThen( Expression.Not(tryUnaryOperationCall), throwExc ); var finalAssign = Expression.Assign(finalResult, Expression.Convert(res, binder.ReturnType)); var retBlock = Expression.Block(new[] { thisEvaled, finalResult, res }, thisAssigned, notIf, finalAssign); var restrictions = BindingRestrictions.GetTypeRestriction(Expression, LimitType); return new DynamicMetaObject(retBlock, restrictions); }
public virtual bool TryUnaryOperation (UnaryOperationBinder binder, out object result) { Console.WriteLine ("System.Windows.Interop.ComAutomationMetaObjectProviderBase.TryUnaryOperation: NIEX"); throw new NotImplementedException (); }
/// <summary> /// Forwards the unary operation. /// </summary> /// <param name="binder"></param> /// <param name="result"></param> /// <returns></returns> public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { result = null; try { result = Impromptu.InvokeUnaryOperator(binder.Operation, CallTarget); return true; } catch (RuntimeBinderException) { return false; } }
public virtual bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { result = null; return false; }
public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result) { return base.TryUnaryOperation(binder, out result); }
public virtual new System.Dynamic.DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { Contract.Requires(binder != null); return(default(System.Dynamic.DynamicMetaObject)); }
public virtual new bool TryUnaryOperation(UnaryOperationBinder binder, out Object result) { result = default(Object); return default(bool); }
private DispatchResult DispatchUnaryOperation(UnaryOperationBinder binder, Object arg1) { var old_value = Value; Value = arg1; try { try { try { var result = UnaryOperation(binder); if (result is FallbackException) throw (FallbackException)result; return Succeed(result); } catch (FallbackException) { var dynamic_object = Value as IDynamicObject; if (dynamic_object != null) return Succeed(dynamic_object.UnaryOperation(binder)); else throw; } } catch (FallbackException) { return Fail(); } catch (Exception ex) { if (WrapExceptions) { var bind_args = new OrderedDictionary<String, Object>(); bind_args.Add("arg1", arg1); throw new BindException(binder, bind_args, ex); } else { throw; } } } finally { Value = old_value; } }
public sealed override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { var fallback = ((Func<Expression>)(() => { try { return base.BindUnaryOperation(binder).Expression; } catch (Exception ex) { return Expression.Throw(Expression.Constant(ex)); } }))(); var dispatchResult = Expression.Parameter(typeof(DispatchResult), "dispatchResult"); var shim = Expression.Block(dispatchResult.MkArray(), // 1. var dispatchResult = DispatchUnaryOperation(binder, `expression`); Expression.Assign(dispatchResult, Expression.Call( Expression.Constant(this), typeof(SimpleMetaObject).GetMethod("DispatchUnaryOperation", BF.PrivateInstance), Expression.Constant(binder), Expression)), // 2. return dispatchResult.Success ? dispatchResult.Result : `fallback`; Expression.Condition( Expression.Property(dispatchResult, "Success"), Expression.Convert(Expression.Property(dispatchResult, "Result"), binder.ReturnType), fallback, binder.ReturnType)); return new DynamicMetaObject(shim, BindingRestrictions.GetTypeRestriction(Expression, LimitType)); }
/// <summary> /// Provides the implementation of performing a unary operation. Derived classes can /// override this method to customize behavior. When not overridden the call site requesting /// the binder determines the behavior. /// </summary> /// <param name="binder">The binder provided by the call site.</param> /// <param name="result">The result of the operation.</param> /// <returns>true if the operation is complete, false if the call site should determine behavior.</returns> public virtual bool TryUnaryOperation(UnaryOperationBinder binder, [NotNullWhen(true)] out object?result) { No.Op(binder); result = null; return(false); }
public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder) { if (IsOverridden("TryUnaryOperation")) { return CallMethodWithResult("TryUnaryOperation", binder, NoArgs, (e) => binder.FallbackUnaryOperation(this, e)); } return base.BindUnaryOperation(binder); }
public virtual Object UnaryOperation(UnaryOperationBinder binder){ throw Fallback(); }