//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private org.boris.expr.Expr evaluateArrayJS(ExprAbstractEvaluationContext paramExprAbstractEvaluationContext) throws org.boris.expr.ExprException private Expr evaluateArrayJS(ExprAbstractEvaluationContext paramExprAbstractEvaluationContext) { try { Invocable invocable = (Invocable)Engine; object @object = invocable.invokeFunction(this.fTable.Name, new object[0]); Console.WriteLine("RESULT IS: " + @object); if (@object == null) { throw new ScriptException("Function " + this.fTable.Name + " does not return an array value", this.fTable.Name, 2); } if (@object is NativeArray) { return(ExprArrayUtil.toExprArray((NativeArray)@object)); } if (@object is object[]) { return(ExprArrayUtil.toExprArray((object[])@object)); } if (@object is object[][]) { return(ExprArrayUtil.toExprArray((object[][])@object)); } //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: Console.WriteLine("ARRAY IS OF TYPE: " + @object + " OR " + @object.GetType().FullName); throw new ScriptException("Function " + this.fTable.Name + " does not return an array value", this.fTable.Name, 2); } catch (ScriptException scriptException) { string str = scriptException.Message; if (scriptException.InnerException != null) { str = scriptException.InnerException.Message; } if (str.IndexOf(":", StringComparison.Ordinal) != -1) { str = str.Substring(str.LastIndexOf(":", StringComparison.Ordinal) + 1); } throw new ExprException(str); } catch (Exception exception) { Console.WriteLine(exception.ToString()); Console.Write(exception.StackTrace); throw new ExprException(exception.Message); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private org.boris.expr.Expr evaluateIntegerJS(ExprAbstractEvaluationContext paramExprAbstractEvaluationContext) throws org.boris.expr.ExprException private Expr evaluateIntegerJS(ExprAbstractEvaluationContext paramExprAbstractEvaluationContext) { try { Invocable invocable = (Invocable)Engine; object @object = invocable.invokeFunction(this.fTable.Name, new object[0]); if (@object == null) { throw new ScriptException("Function " + this.fTable.Name + " does not return an integer value", this.fTable.Name, 2); } return(new ExprInteger(int.Parse(@object.ToString()))); } catch (ScriptException scriptException) { string str = scriptException.Message; if (scriptException.InnerException != null) { str = scriptException.InnerException.Message; } if (str.IndexOf(":", StringComparison.Ordinal) != -1) { str = str.Substring(str.LastIndexOf(":", StringComparison.Ordinal) + 1); } throw new ExprException(str); } catch (System.FormatException) { throw new ExprException("Function " + this.fTable.Name + " does not return an integer value"); } catch (Exception exception) { Console.WriteLine(exception.ToString()); Console.Write(exception.StackTrace); throw new ExprException(exception.Message); } }
/// <summary> /// Converts an object of a given formal type to string /// representation which can be unmarshalled (converted back to /// object) on a target computer. /// </summary> /// <remarks> /// It supports objects of following (informal) categories/types: /// primitive, string, IRemotelyCloneable, IRemotelyReferable, /// delegate, System.Void, [Serializable] and array. A null object also /// can be marshalled. /// </remarks> /// <param name="obj">An object to be marshalled. Can be null. /// </param> /// <param name="type">Formal type of the object (only this type will /// be available on a target computer). Must not be null.</param> /// <returns>Marshalled string representation of given object. /// </returns> /// <exception cref="ArgumentNullException" /> /// <exception cref="ArgumentException">If the object type is not /// supported for marshalling.</exception> public static string Marshal(object obj, Type type) { // Parameter 'type' must not be null by contract. if (type == null) { throw new ArgumentNullException("type"); } if (type == typeof(object)) { type = DetermineFormalTypeFromObject(obj); } Func<Type, string, string> composeResultFromFormalTypeAndData = delegate(Type formalType, string data) { return formalType.Assembly.FullName + "!" + formalType.FullName + ":" + data; }; if (type.IsPrimitive) { string result; if (obj is IFormattable) { result = ((IFormattable)obj).ToString(null, CultureInfo.InvariantCulture); } else { result = obj.ToString(); } return composeResultFromFormalTypeAndData(type, result); } if ((type.FullName == "System.Void") || (obj == null)) { return composeResultFromFormalTypeAndData(Type.GetType("System.Void"), string.Empty); } if (type == typeof(string)) { return composeResultFromFormalTypeAndData(typeof(string), (string)obj); } if (typeof(IRemotelyCloneable).IsAssignableFrom(type)) { var clonable = (IRemotelyCloneable)obj; string result = clonable.SerializeClone(); return composeResultFromFormalTypeAndData(type, result); } if (typeof(IRemotelyReferable).IsAssignableFrom(type)) { if (!type.IsInterface) { throw new ArgumentException("The formal type of the remotely referable object must be an interface."); } var remotelyReferable = (IRemotelyReferable)obj; var address = ObjectServer.PublishObject(remotelyReferable); string result = address.Serialize(); return composeResultFromFormalTypeAndData(type, result); } if (typeof(Delegate).IsAssignableFrom(type)) { var target = (Delegate)obj; var invocable = new Invocable(target); var address = ObjectServer.PublishObject(invocable); string result = address.Serialize(); return composeResultFromFormalTypeAndData(type, result); } if (type.GetCustomAttributes(typeof(SerializableAttribute), false).Length > 0) { using (MemoryStream ms = new MemoryStream()) { BinaryFormatter binaryFormatter = new BinaryFormatter(); binaryFormatter.Serialize(ms, obj); byte[] bytes = ms.GetBuffer(); int length = (int)ms.Length; string result = length.ToString() + ":" + Convert.ToBase64String(bytes, 0, length); return composeResultFromFormalTypeAndData(type, result); } } if (type.IsArray) { Array array = (Array)obj; if (array.Rank == 1) { Type elementType = type.GetElementType(); StringBuilder result = new StringBuilder(); for (int i = 0; i < array.Length; i++) { object element = array.GetValue(i); Type elementFormalType = DetermineFormalTypeFromObject(element); result.Append(elementFormalType.ToString()); result.Append(ArrayElementSeparator); result.Append(Marshal(element, elementType)); if (i < array.Length - 1) { result.Append(ArrayElementSeparator); } } return composeResultFromFormalTypeAndData(type, result.ToString()); } } throw new ArgumentException("Cannot marshal given type."); }