private static T OnStack <T>(string p, MappingStack mappingStack, Func <T> func) { mappingStack.Push(p); try { return(func()); } finally { mappingStack.Pop(); } }
protected object MapHashtable( IEnumerator <Node> iter, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { mappedType = null; var retObj = new XmlRpcStruct(); mappingStack.Push("struct mapped to XmlRpcStruct"); try { while (iter.MoveNext() && iter.Current is StructMember) { var rpcName = ((StructMember)iter.Current).Value; if (retObj.ContainsKey(rpcName) && !IgnoreDuplicateMembers) { throw new XmlRpcInvalidXmlRpcException( mappingStack.MappingType + " contains struct value with duplicate member " + rpcName + " " + StackDump(mappingStack)); } iter.MoveNext(); var value = OnStack( string.Format("member {0}", rpcName), mappingStack, () => MapValueNode(iter, null, mappingStack, mappingAction)); if (!retObj.ContainsKey(rpcName)) { retObj[rpcName] = value; } } } finally { mappingStack.Pop(); } return(retObj); }
private object MapArray(IEnumerator <Node> iter, Type valType, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { mappedType = null; // required type must be an array if (valType != null && !(valType.IsArray == true || valType == typeof(Array) || valType == typeof(object))) { throw new XmlRpcTypeMismatchException(mappingStack.MappingType + " contains array value where " + XmlRpcTypeInfo.GetXmlRpcTypeString(valType) + " expected " + StackDump(mappingStack)); } if (valType != null) { XmlRpcType xmlRpcType = XmlRpcTypeInfo.GetXmlRpcType(valType); if (xmlRpcType == XmlRpcType.tMultiDimArray) { mappingStack.Push("array mapped to type " + valType.Name); Object ret = MapMultiDimArray(iter, valType, mappingStack, mappingAction); return(ret); } mappingStack.Push("array mapped to type " + valType.Name); } else { mappingStack.Push("array"); } var values = new List <object>(); Type elemType = DetermineArrayItemType(valType); bool bGotType = false; Type useType = null; while (iter.MoveNext() && iter.Current is ValueNode) { mappingStack.Push(String.Format("element {0}", values.Count)); object value = MapValueNode(iter, elemType, mappingStack, mappingAction); values.Add(value); mappingStack.Pop(); } foreach (object value in values) { if (value == null) { continue; } if (bGotType == false) { useType = value.GetType(); bGotType = true; } else { if (useType != value.GetType()) { useType = null; } } } Object[] args = new Object[1]; args[0] = values.Count; Object retObj = null; if (valType != null && valType != typeof(Array) && valType != typeof(object)) { retObj = CreateArrayInstance(valType, args); } else { if (useType == null) { retObj = CreateArrayInstance(typeof(object[]), args); } else { retObj = Array.CreateInstance(useType, (int)args[0]); }; } for (int j = 0; j < values.Count; j++) { ((Array)retObj).SetValue(values[j], j); } mappingStack.Pop(); return(retObj); }
private object MapStruct(IEnumerator <Node> iter, Type valueType, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { mappedType = null; if (valueType.IsPrimitive) { throw new XmlRpcTypeMismatchException(mappingStack.MappingType + " contains struct value where " + XmlRpcTypeInfo.GetXmlRpcTypeString(valueType) + " expected " + StackDump(mappingStack)); } if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Nullable <>)) { valueType = valueType.GetGenericArguments()[0]; } object retObj; try { retObj = Activator.CreateInstance(valueType); } catch (Exception) { throw new XmlRpcTypeMismatchException(mappingStack.MappingType + " contains struct value where " + XmlRpcTypeInfo.GetXmlRpcTypeString(valueType) + " expected (as type " + valueType.Name + ") " + StackDump(mappingStack)); } // Note: mapping action on a struct is only applied locally - it // does not override the global mapping action when members of the // struct are mapped MappingAction localAction = mappingAction; if (valueType != null) { mappingStack.Push("struct mapped to type " + valueType.Name); localAction = StructMappingAction(valueType, mappingAction); } else { mappingStack.Push("struct"); } // create map of field names and remove each name from it as // processed so we can determine which fields are missing var names = new List <string>(); CreateFieldNamesMap(valueType, names); int fieldCount = 0; List <string> rpcNames = new List <string>(); try { while (iter.MoveNext()) { if (!(iter.Current is StructMember)) { break; } string rpcName = (iter.Current as StructMember).Value; if (rpcNames.Contains(rpcName)) { if (!IgnoreDuplicateMembers) { throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains struct value with duplicate member " + rpcName + " " + StackDump(mappingStack)); } else { continue; } } else { rpcNames.Add(rpcName); } string name = GetStructName(valueType, rpcName) ?? rpcName; MemberInfo mi = valueType.GetField(name); if (mi == null) { mi = valueType.GetProperty(name); } if (mi == null) { iter.MoveNext(); // move to value if (iter.Current is ComplexValueNode) { int depth = iter.Current.Depth; while (!(iter.Current is EndComplexValueNode && iter.Current.Depth == depth)) { iter.MoveNext(); } } continue; } if (names.Contains(name)) { names.Remove(name); } else { if (Attribute.IsDefined(mi, typeof(NonSerializedAttribute))) { mappingStack.Push(String.Format("member {0}", name)); throw new XmlRpcNonSerializedMember("Cannot map XML-RPC struct " + "member onto member marked as [NonSerialized]: " + " " + StackDump(mappingStack)); } } Type memberType = mi.MemberType == MemberTypes.Field ? (mi as FieldInfo).FieldType : (mi as PropertyInfo).PropertyType; string mappingMsg = valueType == null ? String.Format("member {0}", name) : String.Format("member {0} mapped to type {1}", name, memberType.Name); iter.MoveNext(); object valObj = OnStack(mappingMsg, mappingStack, delegate() { return(MapValueNode(iter, memberType, mappingStack, mappingAction)); }); if (mi.MemberType == MemberTypes.Field) { try { (mi as FieldInfo).SetValue(retObj, valObj); } catch { (mi as FieldInfo).SetValue(retObj, Enum.Parse((mi as FieldInfo).FieldType, (string)valObj, true)); } } else { (mi as PropertyInfo).SetValue(retObj, valObj, null); } fieldCount++; } if (localAction == MappingAction.Error && names.Count > 0) { ReportMissingMembers(valueType, names, mappingStack); } return(retObj); } finally { mappingStack.Pop(); } }
public XmlRpcRequest DeserializeRequest(XmlReader rdr, Type svcType) { try { XmlRpcRequest request = new XmlRpcRequest(); IEnumerator <Node> iter = new XmlRpcParser().ParseRequest(rdr).GetEnumerator(); iter.MoveNext(); string methodName = (iter.Current as MethodName).Name; request.method = methodName; request.mi = null; ParameterInfo[] pis = null; if (svcType != null) { // retrieve info for the method which handles this XML-RPC method XmlRpcServiceInfo svcInfo = XmlRpcServiceInfo.CreateServiceInfo(svcType); request.mi = svcInfo.GetMethodInfo(request.method); // if a service type has been specified and we cannot find the requested // method then we must throw an exception if (request.mi == null) { string msg = String.Format("unsupported method called: {0}", request.method); throw new XmlRpcUnsupportedMethodException(msg); } // method must be marked with XmlRpcMethod attribute Attribute attr = Attribute.GetCustomAttribute(request.mi, typeof(XmlRpcMethodAttribute)); if (attr == null) { throw new XmlRpcMethodAttributeException( "Method must be marked with the XmlRpcMethod attribute."); } pis = request.mi.GetParameters(); } bool gotParams = iter.MoveNext(); if (!gotParams) { if (svcType != null) { if (pis.Length == 0) { request.args = new object[0]; return(request); } else { throw new XmlRpcInvalidParametersException( "Method takes parameters and params element is missing."); } } else { request.args = new object[0]; return(request); } } int paramsPos = pis != null?GetParamsPos(pis) : -1; Type paramsType = null; if (paramsPos != -1) { paramsType = pis[paramsPos].ParameterType.GetElementType(); } int minParamCount = pis == null ? int.MaxValue : (paramsPos == -1 ? pis.Length : paramsPos); MappingStack mappingStack = new MappingStack("request"); MappingAction mappingAction = MappingAction.Error; var objs = new List <object>(); var paramsObjs = new List <object>(); int paramCount = 0; while (iter.MoveNext()) { paramCount++; if (svcType != null && paramCount > minParamCount && paramsPos == -1) { throw new XmlRpcInvalidParametersException( "Request contains too many param elements based on method signature."); } if (paramCount <= minParamCount) { if (svcType != null) { mappingStack.Push(String.Format("parameter {0}", paramCount)); // TODO: why following commented out? // parseStack.Push(String.Format("parameter {0} mapped to type {1}", // i, pis[i].ParameterType.Name)); var obj = MapValueNode(iter, pis[paramCount - 1].ParameterType, mappingStack, mappingAction); objs.Add(obj); } else { mappingStack.Push(String.Format("parameter {0}", paramCount)); var obj = MapValueNode(iter, null, mappingStack, mappingAction); objs.Add(obj); } mappingStack.Pop(); } else { mappingStack.Push(String.Format("parameter {0}", paramCount + 1)); var paramsObj = MapValueNode(iter, paramsType, mappingStack, mappingAction); paramsObjs.Add(paramsObj); mappingStack.Pop(); } } if (svcType != null && paramCount < minParamCount) { throw new XmlRpcInvalidParametersException( "Request contains too few param elements based on method signature."); } if (paramsPos != -1) { Object[] args = new Object[1]; args[0] = paramCount - minParamCount; Array varargs = (Array)Activator.CreateInstance(pis[paramsPos].ParameterType, args); for (int i = 0; i < paramsObjs.Count; i++) { varargs.SetValue(paramsObjs[i], i); } objs.Add(varargs); } request.args = objs.ToArray(); return(request); } catch (XmlException ex) { throw new XmlRpcIllFormedXmlException("Request contains invalid XML", ex); } }