public virtual void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node) { object v; _name = XmlSerialization.GetAttribute(node, XmlSerialization.XMLATT_NAME); _static = XmlSerialization.GetAttributeBool(node, XmlSerialization.XMLATT_STATIC); MakeUIThreadSafe = XmlSerialization.GetAttributeBool(node, XmlSerialization.XMLATT_UIThreadSafe); if (XmlSerialization.ReadValueFromChildNode(node, XmlSerialization.XML_DESCRIPT, out v)) { _desc = (string)v; } XmlNode nd = node.SelectSingleNode(XmlSerialization.XML_RETURNTYPE); if (nd != null) { _returnType = (RaisDataType)XmlSerialization.ReadFromXmlNode(serializer, nd); } else { _returnType = new RaisDataType(typeof(double)); } string qry = XmlSerialization.FormatString("{0}/{1}", XmlSerialization.XML_PARAMLIST, XmlSerialization.XML_PARAM); XmlNodeList nodes = node.SelectNodes(qry); if (nodes != null && nodes.Count > 0) { _parameters = new Parameter[nodes.Count]; for (int i = 0; i < nodes.Count; i++) { _parameters[i] = (Parameter)XmlSerialization.ReadFromXmlNode(serializer, nodes[i]); } } this.MethodID = XmlSerialization.GetAttributeUInt(node, XmlSerialization.XMLATT_ID); }
public void SetType(RaisDataType t) { this.DevType = t.DevType; this.Name = t.Name; this.LibType = t.LibType; Variable.VariableType = t; }
public Parameter(MethodType method, RaisDataType rt) : this(method) { _method = null; SetType(rt); _method = method; }
public bool IsSameType(RaisDataType type) { if (type == null) { return(false); } if (this.IsLibType) { if (_libType == null) { return(false); } if (type.IsLibType) { return(this.LibType.Equals(type.LibType)); } } else { if (!type.IsLibType) { if (DevType == null) { return(false); } return(this.DevType.IsSameType(type.DevType)); } } return(false); }
public MethodRef(ObjectRef owner, string name, int id, ParameterDef[] parameters, RaisDataType returnType) { _methodOwnerObjectRef = owner; _methodName = name; _methodId = id; _parameters = parameters; _retType = returnType; }
/// <summary> /// create conversion code /// </summary> /// <param name="sourceType"></param> /// <param name="sourceCode"></param> /// <param name="targetType"></param> /// <returns>conversion code converting sourceCode to the targetType</returns> public static CodeExpression GetConversionCode(RaisDataType sourceType, CodeExpression sourceCode, RaisDataType targetType, CodeStatementCollection supprtStatements) { CodeExpression codeRet; if (sourceType.IsSameType(targetType)) { return(sourceCode); } if (targetType.IsLibType || sourceType.IsLibType) { if (MathNode.GetTypeConversion != null) { return(MathNode.GetTypeConversion(targetType.Type, sourceCode, sourceType.Type, supprtStatements)); } return(CastOrConvert(sourceCode, sourceType.Type, targetType.Type, supprtStatements)); } string srcType = sourceType.DevType.TypeString; string tgtType = targetType.DevType.TypeString; if (srcType.StartsWith(tgtType)) { return(sourceCode); } if (tgtType.StartsWith(srcType)) { return(new CodeCastExpression(tgtType, VPLUtil.GetCoreExpressionFromCast(sourceCode))); } TypeConverter converter = TypeDescriptor.GetConverter(targetType.Type); if (converter.CanConvertFrom(sourceType.Type)) { MathNode.AddImportLocation(typeof(TypeConverter).Assembly.Location); string converterName = "conv" + targetType.Type.Name; if (!MathNodeVariable.VariableDeclared(supprtStatements, converterName)) { CodeVariableDeclarationStatement cs1 = new CodeVariableDeclarationStatement( typeof(TypeConverter), converterName, new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(typeof(TypeDescriptor)), "GetConverter", new CodeExpression[] { new CodeSnippetExpression("typeof(" + tgtType + ")") })); supprtStatements.Add(cs1); } //================================================= // codeRet = new CodeCastExpression(tgtType, new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(converterName), "ConvertFrom", new CodeExpression[] { sourceCode })); MathNode.Trace("\tcode 102: source type:{0}, target type:{1} result=converter.ConvertFrom(code);", sourceType, targetType); } else { codeRet = CastOrConvert(sourceCode, sourceType.Type, targetType.Type, supprtStatements); } return(codeRet); }
public virtual object Clone() { RaisDataType obj = (RaisDataType)Activator.CreateInstance(this.GetType(), _libType, _name); obj.Description = Description; if (_devType != null) { obj.DevType = (ObjectRef)_devType.Clone(); } obj.SetServiceProvider(_serviceProvider); return(obj); }
private void getSignature(MethodInfo mi) { _retType = new RaisDataType(mi.ReturnType); ParameterInfo[] ps = mi.GetParameters(); if (ps != null && ps.Length > 0) { _parameters = new ParameterDef[ps.Length]; for (int i = 0; i < ps.Length; i++) { _parameters[i] = new ParameterDef(ps[i].ParameterType, ps[i].Name); } } }
public Parameter AddNewParameter(RaisDataType p) { int n = 1; string sbase = "parameter"; string name = sbase + n.ToString(); if (_parameters != null) { bool b = true; while (b) { b = false; for (int i = 0; i < _parameters.Length; i++) { if (_parameters[i].Name == name) { b = true; break; } } if (b) { n++; name = sbase + n.ToString(); } } } p.Name = name; if (_parameters != null) { n = _parameters.Length; Parameter[] a = new Parameter[n + 1]; for (int i = 0; i < n; i++) { a[i] = _parameters[i]; } _parameters = a; } else { _parameters = new Parameter[1]; n = 0; } _parameters[n] = new Parameter(this, p); _parameters[n].Variable.MathExpression.Dummy.ResetID(this.MethodID); return(_parameters[n]); }
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node) { XmlNode methodXmlNode = null; _methodName = XmlSerialization.GetAttribute(node, XmlSerialization.XMLATT_NAME); _methodId = XmlSerialization.GetAttributeInt(node, XmlSerialization.XMLATT_ID); _methodOwnerObjectRef = (ObjectRef)XmlSerialization.ReadFromChildXmlNode(serializer, node, XmlSerialization.XML_METHODOWNER, new object[] { null }); if (_methodId != 0) { methodXmlNode = node.OwnerDocument.SelectSingleNode( XmlSerialization.FormatString("//{0}[@{1}='{2}']", XmlSerialization.XML_METHOD, XmlSerialization.XMLATT_ID, _methodId)); } if (methodXmlNode == null) { if (_methodId != 0) { throw new MathException("Method {0} not found", _methodId); } _retType = (RaisDataType)XmlSerialization.ReadFromChildXmlNode(serializer, node, XmlSerialization.XML_RETURNTYPE); XmlNodeList pNodes = node.SelectNodes(XmlSerialization.XML_PARAM); if (pNodes != null) { _parameters = new ParameterDef[pNodes.Count]; for (int i = 0; i < pNodes.Count; i++) { _parameters[i] = (ParameterDef)XmlSerialization.ReadFromXmlNode(serializer, pNodes[i]); } } } else { MethodType mt = new MethodType(); mt.OnReadFromXmlNode(serializer, methodXmlNode); _retType = mt.ReturnType; Parameter[] ps = mt.Parameters; if (ps != null && ps.Length > 0) { _parameters = new ParameterDef[ps.Length]; for (int i = 0; i < ps.Length; i++) { _parameters[i] = new ParameterDef(ps[i], ps[i].Name); } } } }
public virtual CodeExpression ReturnCodeExpression(IMethodCompile method) { string s = method.GetParameterCodeNameById(this.ID); bool bFound = !string.IsNullOrEmpty(s); if (bFound) { if (_code != null) { return(_code); } _actualCompiledType = null; return(new CodeArgumentReferenceExpression(Variable.CodeVariableName)); } else { _actualCompiledType = new RaisDataType(this.DataType.Type); return(ValueTypeUtil.GetDefaultCodeByType(this.DataType.Type)); } }
public ValueForSetProperty(MethodType method, RaisDataType rt) : base(method, rt) { }
public void SetDataType(RaisDataType type) { SetType(type); }
public ParameterDef(RaisDataType tp, string name) : this(tp) { this.Name = name; }
public ParameterDef(RaisDataType tp) { this.DataType = tp; }
public Parameter(RaisDataType t) : base(t) { Init(); }
/// <summary> /// retrieve _retyrnType and parameters /// </summary> private void getSignature() { if (string.IsNullOrEmpty(_methodName)) { throw new MathException("Accessing getSignature with empty method name"); } if (_methodOwnerObjectRef == null) { throw new MathException("Accessing getSignature with null owner"); } if (_methodOwnerObjectRef.Type == ObjectRefType.Type) { Type t = _methodOwnerObjectRef.Value.LibType; MethodInfo mi = t.GetMethod(_methodName); if (mi == null) { throw new MathException("Accessing getSignature with invalid method name '{0}'", _methodName); } getSignature(mi); } else if (_methodOwnerObjectRef.Type == ObjectRefType.Field || _methodOwnerObjectRef.Type == ObjectRefType.Property) { if (_methodOwnerObjectRef.Owner.Type == ObjectRefType.XPath) { } else if (_methodOwnerObjectRef.Owner.Type == ObjectRefType.Type) { MethodInfo mi = null; Type t = _methodOwnerObjectRef.Owner.Value.LibType; if (_methodOwnerObjectRef.Type == ObjectRefType.Field) { FieldInfo fi = t.GetField(_methodOwnerObjectRef.Name); if (fi == null) { throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Field with invalid field name {0} for type {1}", _methodOwnerObjectRef.Name, t)); } mi = fi.FieldType.GetMethod(_methodName); if (mi == null) { throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Field with invalid method name {0} for field name {1} and type {2}", _methodName, _methodOwnerObjectRef.Name, t)); } } else if (_methodOwnerObjectRef.Type == ObjectRefType.Property) { PropertyInfo pi = t.GetProperty(_methodOwnerObjectRef.Name); if (pi == null) { throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Property with invalid property name {0} for type {1}", _methodOwnerObjectRef.Name, t)); } mi = pi.PropertyType.GetMethod(_methodName); if (mi == null) { throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Property with invalid method name {0} for Property name {1} and type {2}", _methodName, _methodOwnerObjectRef.Name, t)); } } getSignature(mi); } throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Field. Owner type {0} not implemented", _methodOwnerObjectRef.Owner.Type)); } else if (_methodOwnerObjectRef.Type == ObjectRefType.XPath) { XmlDocument doc = _methodOwnerObjectRef.GetXmlDocument(); if (doc == null) { throw new MathException("Accessing getSignature with null document"); } XmlNode prj = XmlSerialization.GetProjectNode(doc); if (prj == null) { throw new MathException("Accessing getSignature with null project"); } XmlNode ownNode = prj.SelectSingleNode(_methodOwnerObjectRef.XPath); if (ownNode == null) { throw new MathException(XmlSerialization.FormatString("Accessing getSignature with invalid xpath {0}", _methodOwnerObjectRef.XPath)); } if (_methodName == XmlSerialization.CONSTRUCTOR_METHOD) { throw new MathException("Accessing getSignature when the method is a constructor"); } XmlNode methodNode = ownNode.SelectSingleNode(XmlSerialization.FormatString("{0}[@{1}='{2}']", XmlSerialization.XML_METHOD, XmlSerialization.XMLATT_NAME, _methodName)); if (methodNode == null) { Type t = XmlSerialization.GetObjectLibType(ownNode); if (t == null) { throw new MathException(XmlSerialization.FormatString("Accessing getSignature with valid xpath {0} but method name {1} not found and owner library type not found", _methodOwnerObjectRef.XPath, _methodName)); } MethodInfo mif = t.GetMethod(_methodName); if (mif == null) { throw new MathException(XmlSerialization.FormatString("Accessing getSignature with valid xpath {0} but method name {1} not found in owner library type {2}", _methodOwnerObjectRef.XPath, _methodName, t.Name)); } getSignature(mif); } else { MethodType mt = new MethodType(); mt.OnReadFromXmlNode(null, methodNode); _retType = mt.ReturnType; Parameter[] ps = mt.Parameters; if (ps != null && ps.Length > 0) { _parameters = new ParameterDef[ps.Length]; for (int i = 0; i < ps.Length; i++) { _parameters[i] = new ParameterDef(ps[i]); } } } } throw new MathException(XmlSerialization.FormatString("Accessing getSignature: type not implemented: {0}", _methodOwnerObjectRef.Type)); }