public static XmlDocument Serialize( string testName, object obj, Encoding encoding, MappingAction action) { Stream stm = new MemoryStream(); XmlTextWriter xtw = new XmlTextWriter(stm, Encoding.UTF8); xtw.Formatting = Formatting.Indented; xtw.Indentation = 2; xtw.WriteStartDocument(); XmlRpcSerializer ser = new XmlRpcSerializer(); ser.Serialize(xtw, obj, action); xtw.Flush(); //Console.WriteLine(testName); stm.Position = 0; TextReader trdr = new StreamReader(stm, new UTF8Encoding(), true, 4096); String s = trdr.ReadLine(); while (s != null) { //Console.WriteLine(s); s = trdr.ReadLine(); } stm.Position = 0; XmlDocument xdoc = new XmlDocument(); xdoc.PreserveWhitespace = true; xdoc.Load(stm); return xdoc; }
private XmlRpcException DeserializeFault(IEnumerator <Node> iter) { MappingStack faultStack = new MappingStack("fault response"); // TODO: use global action setting MappingAction mappingAction = MappingAction.Error; XmlRpcFaultException faultEx = ParseFault(iter, faultStack, // TODO: fix mappingAction); throw faultEx; }
public SerializerConfig() { Indentation = 2; NonStandard = XmlRpcNonStandard.None; UseEmptyParamsTag = true; UseIndentation = true; UseIntTag = false; UseStringTag = true; XmlEncoding = null; MappingAction = MappingAction.Error; }
private object MapString(string value, Type valType, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { CheckExpectedType(valType, typeof(string), mappingStack); if (valType != null && valType.IsEnum) { return(MapStringToEnum(value, valType, "i8", mappingStack, mappingAction, out mappedType)); } mappedType = typeof(string); return(OnStack("string", mappingStack, delegate() { return value; })); }
public static object Parse( XmlReader rdr, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { parsedType = parsedArrayType = null; rdr.ReadToDescendant("value"); var mappingStack = new MappingStack("request"); return new XmlRpcDeserializer().ParseValueElement(rdr, valueType, mappingStack, action); }
//----------------------------------------------------------------------// public static object Parse( string xml, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { StringReader sr = new StringReader(xml); XmlReader rdr = XmlRpcXmlReader.Create(sr); return Parse(rdr, valueType, action, out parsedType, out parsedArrayType); }
/// <summary> /// /// </summary> /// <param name="rdr"></param> /// <param name="valType"></param> /// <param name="mappingStack"></param> /// <param name="mappingAction"></param> /// <returns></returns> public Object ParseValueElement( XmlReader rdr, Type valType, MappingStack mappingStack, MappingAction mappingAction) { var iter = new XmlRpcParser().ParseValue(rdr).GetEnumerator(); iter.MoveNext(); return(MapValueNode(iter, valType, mappingStack, mappingAction)); }
//----------------------------------------------------------------------// public static object Parse( string xml, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { StringReader sr = new StringReader(xml); XmlReader rdr = XmlRpcXmlReader.Create(sr); return(Parse(rdr, valueType, action, out parsedType, out parsedArrayType)); }
public static object Parse( XmlReader rdr, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { parsedType = parsedArrayType = null; rdr.ReadToDescendant("value"); var mappingStack = new MappingStack("request"); return(new XmlRpcDeserializer().ParseValueElement(rdr, valueType, mappingStack, action)); }
public static object ParseValue(string xml, Type valueType) { MappingAction action = MappingAction.Error; StringReader sr = new StringReader(xml); XmlReader rdr = XmlRpcXmlReader.Create(sr); rdr.MoveToContent(); MappingStack parseStack = new MappingStack("value"); var deser = new XmlRpcDeserializer(); object obj = deser.ParseValueElement(rdr, valueType, parseStack, action); return(obj); }
public static object Parse( XmlReader rdr, Type valueType, MappingAction action, XmlRpcDeserializer deserializer, out Type parsedType, out Type parsedArrayType) { parsedType = parsedArrayType = null; rdr.ReadToDescendant("value"); MappingStack parseStack = new MappingStack("request"); object obj = deserializer.ParseValueElement(rdr, valueType, parseStack, action); return obj; }
XmlRpcFaultException ParseFault( IEnumerator <Node> iter, MappingStack parseStack, MappingAction mappingAction) { iter.MoveNext(); // move to StructValue Type parsedType; var faultStruct = MapHashtable(iter, null, parseStack, mappingAction, out parsedType) as XmlRpcStruct; object faultCode = faultStruct["faultCode"]; object faultString = faultStruct["faultString"]; return(new XmlRpcFaultException($"{faultCode}", (string)faultString)); }
//----------------------------------------------------------------------// public static object Parse( string xml, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { StringReader sr = new StringReader(xml); XmlDocument xdoc = new XmlDocument(); xdoc.Load(sr); return(Parse(xdoc, valueType, action, out parsedType, out parsedArrayType)); }
private object MapMultiDimArray( IEnumerator <Node> iter, Type valueType, MappingStack mappingStack, MappingAction mappingAction) { // parse the type name to get element type and array rank var elemType = valueType.GetElementType(); var rank = valueType.GetArrayRank(); // elements will be stored sequentially as nested arrays are mapped var elements = new List <object>(); // create array to store length of each dimension - initialize to // all zeroes so that when parsing we can determine if an array for // that dimension has been mapped already var dimLengths = new int[rank]; dimLengths.Initialize(); MapMultiDimElements(iter, rank, 0, elemType, elements, dimLengths, mappingStack, mappingAction); // build arguments to define array dimensions and create the array var args = new object[dimLengths.Length]; for (var argi = 0; argi < dimLengths.Length; argi++) { args[argi] = dimLengths[argi]; } var ret = (Array)CreateArrayInstance(valueType, args); // copy elements into new multi-dim array // !! make more efficient var length = ret.Length; for (var e = 0; e < length; e++) { var indices = new int[dimLengths.Length]; var div = 1; for (var f = indices.Length - 1; f >= 0; f--) { indices[f] = (e / div) % dimLengths[f]; div *= dimLengths[f]; } ret.SetValue(elements[e], indices); } return(ret); }
static NullMappingAction MapToNullMappingAction(MappingAction missingMappingAction) { switch (missingMappingAction) { case MappingAction.Error: return(NullMappingAction.Error); case MappingAction.Ignore: return(NullMappingAction.Ignore); default: throw new XmlRpcException("Unexpected missingMappingAction in MapToNullMappingAction"); } }
//----------------------------------------------------------------------// public static object Parse( string xml, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { StringReader sr = new StringReader(xml); XmlDocument xdoc = new XmlDocument(); xdoc.PreserveWhitespace = true; xdoc.Load(sr); return Parse(xdoc, valueType, action, out parsedType, out parsedArrayType); }
private static MappingAction StructMappingAction(Type type, MappingAction currentAction) { // if struct member has mapping action attribute, override the current // mapping action else just return the current action if (type == null) { return(currentAction); } var attr = Attribute.GetCustomAttribute(type, typeof(XmlRpcMissingMappingAttribute)) as XmlRpcMissingMappingAttribute; return(attr == null ? currentAction : attr.Action); }
public static object Parse( XmlReader rdr, Type valueType, MappingAction action, XmlRpcDeserializer deserializer, out Type parsedType, out Type parsedArrayType) { parsedType = parsedArrayType = null; rdr.ReadToDescendant("value"); MappingStack parseStack = new MappingStack("request"); object obj = deserializer.ParseValueElement(rdr, valueType, parseStack, action); return(obj); }
public static object Parse( XmlDocument xdoc, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { XmlNode node = SelectValueNode(xdoc.SelectSingleNode("value")); XmlRpcSerializer.ParseStack parseStack = new XmlRpcSerializer.ParseStack("request"); XmlRpcSerializer ser = new XmlRpcSerializer(); object obj = ser.ParseValue(node, valueType, parseStack, action, out parsedType, out parsedArrayType); return obj; }
/// <summary> /// Adds a member mapping action to the mapper. /// </summary> /// <param name="sourceMemberName">The name of the source member.</param> /// <param name="targetMemberName">The name of the target member.</param> /// <param name="mappingAction">The mapping action.</param> /// <remarks> /// Use this method to add mapping actions through code. /// </remarks> public void AddMappingAction( string sourceMemberName, string targetMemberName, MappingAction <TSource, TTarget> mappingAction) { /* * var info = new DelegateMappingInfo<TSource, TTarget>( * sourceMember, * targetMember, * mappingAction); * * this.AddMappingInfo(info); */ this.ExtensibleMapper.AddMappingAction(sourceMemberName, targetMemberName, mappingAction); }
//----------------------------------------------------------------------// public static object Parse( string xml, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { var sr = new StringReader(xml); var xdoc = new XmlDocument(); xdoc.PreserveWhitespace = true; xdoc.Load(sr); return(Parse(xdoc, valueType, action, out parsedType, out parsedArrayType)); }
public void AddMappingGeneric_DefaultCase_RedirectsToMapper() { var target = new MappingRepository(); var mapperMock = A.Fake <IExtensibleMapper <TSource, TTarget> >(); target.AddMapper <TSource, TTarget>(mapperMock); var sourceMemberName = "source"; var targetMemberName = "target"; var mappingAction = new MappingAction <TSource, TTarget>((s, t) => { }); target.AddMappingAction(sourceMemberName, targetMemberName, mappingAction); A.CallTo(() => mapperMock.AddMappingAction(sourceMemberName, targetMemberName, mappingAction)) .MustHaveHappened(); }
public static MappingAction StructMappingAction(Type type, MappingAction currentAction) { if (type == null) { return(currentAction); } var attr = Attribute.GetCustomAttribute(type, typeof(XmlRpcMissingMappingAttribute)); if (attr == null) { return(currentAction); } return(((XmlRpcMissingMappingAttribute)attr).Action); }
public static object Parse( XmlDocument xdoc, Type valueType, MappingAction action, out Type parsedType, out Type parsedArrayType) { XmlNode node = SelectValueNode(xdoc.SelectSingleNode("value")); var parseStack = new XmlRpcSerializer.ParseStack("request"); var ser = new XmlRpcSerializer(); object obj = ser.ParseValue(node, valueType, parseStack, action, out parsedType, out parsedArrayType); return(obj); }
Object MapMultiDimArray(IEnumerator <Node> iter, Type ValueType, MappingStack mappingStack, MappingAction mappingAction) { // parse the type name to get element type and array rank #if (!COMPACT_FRAMEWORK) Type elemType = ValueType.GetElementType(); int rank = ValueType.GetArrayRank(); #else string[] checkMultiDim = Regex.Split(ValueType.FullName, "\\[,[,]*\\]$"); Type elemType = Type.GetType(checkMultiDim[0]); string commas = ValueType.FullName.Substring(checkMultiDim[0].Length + 1, ValueType.FullName.Length - checkMultiDim[0].Length - 2); int rank = commas.Length + 1; #endif // elements will be stored sequentially as nested arrays are mapped var elements = new List <object>(); // create array to store length of each dimension - initialize to // all zeroes so that when parsing we can determine if an array for // that dimension has been mapped already int[] dimLengths = new int[rank]; dimLengths.Initialize(); MapMultiDimElements(iter, rank, 0, elemType, elements, dimLengths, mappingStack, mappingAction); // build arguments to define array dimensions and create the array Object[] args = new Object[dimLengths.Length]; for (int argi = 0; argi < dimLengths.Length; argi++) { args[argi] = dimLengths[argi]; } Array ret = (Array)CreateArrayInstance(ValueType, args); // copy elements into new multi-dim array //!! make more efficient int length = ret.Length; for (int e = 0; e < length; e++) { int[] indices = new int[dimLengths.Length]; int div = 1; for (int f = (indices.Length - 1); f >= 0; f--) { indices[f] = (e / div) % dimLengths[f]; div *= dimLengths[f]; } ret.SetValue(elements[e], indices); } return(ret); }
public static string SerializeToString( string testName, object obj, MappingAction action) { StringWriter strwrtr = new StringWriter(); XmlTextWriter xtw = new XmlTextWriter(strwrtr); // xtw.Formatting = formatting; // xtw.Indentation = indentation; xtw.WriteStartDocument(); XmlRpcSerializer ser = new XmlRpcSerializer(); ser.Serialize(xtw, obj, action); xtw.Flush(); //Console.WriteLine(testName); //Console.WriteLine(strwrtr.ToString()); return strwrtr.ToString(); }
public static object Parse( string xml, Type valueType, MappingAction action, XmlRpcDeserializer serializer, out Type parsedType, out Type parsedArrayType) { var sr = new StringReader(xml); return Parse( XmlRpcXmlReader.Create(sr), valueType, action, serializer, out parsedType, out parsedArrayType); }
private MappingAction StructMappingAction(Type type, MappingAction currentAction) { if (type == null) { return(currentAction); } Attribute customAttribute = Attribute.GetCustomAttribute(type, typeof(XmlRpcMissingMappingAttribute)); if (customAttribute != null) { return(((XmlRpcMissingMappingAttribute)customAttribute).Action); } else { return(currentAction); } }
private object MapNilValue(string p, Type type, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { if (type == null || (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>)) || (!type.IsPrimitive || !type.IsValueType) || type == typeof(object)) { mappedType = type; return(null); } throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains <nil> value which cannot be mapped to type " + (type != null && type != typeof(object) ? type.Name : "object") + " " + StackDump(mappingStack)); }
public void AddMapping_MockedInternalMappers_Redirects() { BaseMapper <TestClassB, TestClassD>[] mapperMocks = A.CollectionOfFake <BaseMapper <TestClassB, TestClassD> >(5).ToArray(); var extMock = A.Fake <BaseMapper <TestClassB, TestClassD> >( o => o.Implements(typeof(IExtensibleMapper <TestClassB, TestClassD>))); var results = new List <IEnumerable <MemberMappingInfo <TestClassB, TestClassD> > >(); Randomizer rnd = Randomizer.GetRandomizer(typeof(CompositeMapper <,>).GetMethod("AddMapping")); int extPos = rnd.Next(mapperMocks.Length); for (int i = 0; i < mapperMocks.Length; ++i) { var res = new[] { A.Fake <MemberMappingInfo <TestClassB, TestClassD> >( o => o.WithArgumentsForConstructor( new object[] { Guid.NewGuid().ToString(), Guid.NewGuid().ToString() })) }; if (i == extPos) { mapperMocks[i] = extMock; } results.Add(res); A.CallTo(() => mapperMocks[i].GetMappings()) .Returns(res); } var target = new CompositeMapper <TestClassB, TestClassD>(mapperMocks); var source = new TestClassB(); var result = new TestClassD(); MappingAction <TestClassB, TestClassD> action = (s, t) => t.SomeOtherName = s.Name; target.AddMappingAction("foo", "bar", action); target.ExtensibleMapper.ShouldBeSameAs(extMock); A.CallTo(() => ((IExtensibleMapper <TestClassB, TestClassD>)extMock).AddMappingAction("foo", "bar", action)) .MustHaveHappened(); }
MappingAction StructMappingAction( Type type, MappingAction currentAction) { // if struct member has mapping action attribute, override the current // mapping action else just return the current action if (type == null) { return(currentAction); } Attribute attr = type.GetTypeInfo().GetCustomAttribute <XmlRpcMissingMappingAttribute>(); if (attr != null) { return(((XmlRpcMissingMappingAttribute)attr).Action); } return(currentAction); }
public static object Parse( string xml, Type valueType, MappingAction action, XmlRpcDeserializer serializer, out Type parsedType, out Type parsedArrayType) { var sr = new StringReader(xml); return(Parse( XmlRpcXmlReader.Create(sr), valueType, action, serializer, out parsedType, out parsedArrayType)); }
public static string SerializeToString( string testName, object obj, MappingAction action) { StringWriter strwrtr = new StringWriter(); XmlTextWriter xtw = new XmlTextWriter(strwrtr); // xtw.Formatting = formatting; // xtw.Indentation = indentation; xtw.WriteStartDocument(); XmlRpcSerializer ser = new XmlRpcSerializer(); ser.Serialize(xtw, obj, action); xtw.Flush(); //Console.WriteLine(testName); //Console.WriteLine(strwrtr.ToString()); return(strwrtr.ToString()); }
private object MapDouble(string value, Type valType, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { CheckExpectedType(valType, typeof(double), mappingStack); mappedType = typeof(double); return(OnStack("double", mappingStack, delegate() { try { double ret = Double.Parse(value, CultureInfo.InvariantCulture.NumberFormat); return ret; } catch (Exception) { throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains invalid double value " + StackDump(mappingStack)); } })); }
protected object MapHashtable(IEnumerator <Node> iter, Type valType, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { mappedType = null; var xmlRpcStruct = new XmlRpcStruct(); (mappingStack).Push("struct mapped to XmlRpcStruct"); try { while (iter.MoveNext()) { if (iter.Current is StructMember) { string str = (iter.Current as StructMember).Value; if (xmlRpcStruct.ContainsKey(str) && !IgnoreDuplicateMembers) { throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains struct value with duplicate member " + str + " " + StackDump(mappingStack)); } else { iter.MoveNext(); object obj = OnStack(string.Format("member {0}", str), mappingStack, (() => MapValueNode(iter, null, mappingStack, mappingAction))); if (!xmlRpcStruct.ContainsKey(str)) { xmlRpcStruct[str] = obj; } } } else { break; } } } finally { mappingStack.Pop(); } return(xmlRpcStruct); }
private XmlRpcFaultException ParseFault(IEnumerator<Node> iter, MappingStack parseStack, MappingAction mappingAction) { iter.MoveNext(); Type mappedType; var xmlRpcStruct = MapHashtable(iter, null, parseStack, mappingAction, out mappedType) as XmlRpcStruct; object obj1 = xmlRpcStruct["faultCode"]; object obj2 = xmlRpcStruct["faultString"]; if (obj1 is string) { int result; if (!int.TryParse(obj1 as string, out result)) throw new XmlRpcInvalidXmlRpcException("faultCode not int or string"); obj1 = result; } return new XmlRpcFaultException((int)obj1, (string)obj2); }
private object MapLong(string value, Type valType, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { CheckExpectedType(valType, typeof(long), mappingStack); if (valType != null && valType.GetTypeInfo().IsEnum) { return(MapNumberToEnum(value, valType, "i8", mappingStack, mappingAction, out mappedType)); } mappedType = typeof(long); return(OnStack("i8", mappingStack, delegate() { long ret; if (!Int64.TryParse(value, out ret)) { throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains invalid i8 value " + StackDump(mappingStack)); } return ret; })); }
private object MapInt(string value, Type valType, MappingStack mappingStack, MappingAction mappingAction, out Type mappedType) { CheckExpectedType(valType, typeof(int), mappingStack); if (valType != null && valType.IsEnum) { return(MapNumberToEnum(value, valType, "int", mappingStack, mappingAction, out mappedType)); } mappedType = typeof(int); return(OnStack("integer", mappingStack, delegate() { int ret; if (!Int32.TryParse(value, out ret)) { throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains invalid int value " + StackDump(mappingStack)); } return ret; })); }
private XmlRpcFaultException ParseFault(IEnumerator <Node> iter, MappingStack parseStack, MappingAction mappingAction) { iter.MoveNext(); Type mappedType; var xmlRpcStruct = MapHashtable(iter, null, parseStack, mappingAction, out mappedType) as XmlRpcStruct; object obj1 = xmlRpcStruct["faultCode"]; object obj2 = xmlRpcStruct["faultString"]; if (obj1 is string) { int result; if (!int.TryParse(obj1 as string, out result)) { throw new XmlRpcInvalidXmlRpcException("faultCode not int or string"); } obj1 = result; } return(new XmlRpcFaultException((int)obj1, (string)obj2)); }
//#if (DEBUG) //#endif public Object ParseValue( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction, out Type ParsedType, out Type ParsedArrayType) { ParsedType = null; ParsedArrayType = null; // if suppplied type is System.Object then ignore it because // if doesn't provide any useful information (parsing methods // expect null in this case) Type valType = ValueType; if (valType != null && valType.BaseType == null) valType = null; Object retObj = null; if (node == null) { retObj = ""; } else if (node is XmlText || node is XmlWhitespace) { if (valType != null && valType != typeof(string)) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains implicit string value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(valType) + " expected " + StackDump(parseStack)); } retObj = node.Value; } else { if (node.Name == "array") retObj = ParseArray(node, valType, parseStack, mappingAction); else if (node.Name == "base64") retObj = ParseBase64(node, valType, parseStack, mappingAction); else if (node.Name == "struct") { // if we don't know the expected struct type then we must // parse the XML-RPC struct as an instance of XmlRpcStruct if (valType != null && valType != typeof(XmlRpcStruct) && !valType.IsSubclassOf(typeof(XmlRpcStruct))) { retObj = ParseStruct(node, valType, parseStack, mappingAction); } else { if (valType == null || valType == typeof(object)) valType = typeof(XmlRpcStruct); // TODO: do we need to validate type here? retObj = ParseHashtable(node, valType, parseStack, mappingAction); } } else if (node.Name == "i4" // integer has two representations in XML-RPC spec || node.Name == "int") { retObj = ParseInt(node, valType, parseStack, mappingAction); ParsedType = typeof(int); ParsedArrayType = typeof(int[]); } else if (node.Name == "string") { retObj = ParseString(node, valType, parseStack, mappingAction); ParsedType = typeof(string); ParsedArrayType = typeof(string[]); } else if (node.Name == "boolean") { retObj = ParseBoolean(node, valType, parseStack, mappingAction); ParsedType = typeof(bool); ParsedArrayType = typeof(bool[]); } else if (node.Name == "double") { retObj = ParseDouble(node, valType, parseStack, mappingAction); ParsedType = typeof(double); ParsedArrayType = typeof(double[]); } else if (node.Name == "dateTime.iso8601") { retObj = ParseDateTime(node, valType, parseStack, mappingAction); ParsedType = typeof(DateTime); ParsedArrayType = typeof(DateTime[]); } } return retObj; }
MappingAction StructMappingAction( Type type, MappingAction currentAction) { // if struct member has mapping action attribute, override the current // mapping action else just return the current action if (type == null) return currentAction; Attribute attr = Attribute.GetCustomAttribute(type, typeof(XmlRpcMissingMappingAttribute)); if (attr != null) return ((XmlRpcMissingMappingAttribute)attr).Action; return currentAction; }
Object ParseValue( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { Type parsedType; Type parsedArrayType; return ParseValue(node, ValueType, parseStack, mappingAction, out parsedType, out parsedArrayType); }
Object ParseDateTime( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { if (ValueType != null && ValueType != typeof(Object) && ValueType != typeof(System.DateTime) #if !FX1_0 && ValueType != typeof(DateTime?) #endif && ValueType != typeof(XmlRpcDateTime)) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains dateTime.iso8601 value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(ValueType) + " expected " + StackDump(parseStack)); } DateTime retVal; parseStack.Push("dateTime"); try { XmlNode child = node.FirstChild; if (child == null) { if (MapEmptyDateTimeToMinValue) return DateTime.MinValue; else throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains empty dateTime value " + StackDump(parseStack)); } string s = child.Value; // Allow various iso8601 formats, e.g. // XML-RPC spec yyyyMMddThh:mm:ss // WordPress yyyyMMddThh:mm:ssZ // TypePad yyyy-MM-ddThh:mm:ssZ // other yyyy-MM-ddThh:mm:ss if (!DateTime8601.TryParseDateTime8601(s, out retVal)) { if (MapZerosDateTimeToMinValue && s.StartsWith("0000") && (s == "00000000T00:00:00" || s == "0000-00-00T00:00:00Z" || s == "00000000T00:00:00Z" || s == "0000-00-00T00:00:00")) retVal = DateTime.MinValue; else throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains invalid dateTime value " + StackDump(parseStack)); } } finally { parseStack.Pop(); } if (ValueType == typeof(XmlRpcDateTime)) return new XmlRpcDateTime(retVal); else return retVal; }
Object ParseBoolean( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { if (ValueType != null && ValueType != typeof(Object) && ValueType != typeof(System.Boolean) #if !FX1_0 && ValueType != typeof(bool?) #endif && ValueType != typeof(XmlRpcBoolean)) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains boolean value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(ValueType) + " expected " + StackDump(parseStack)); } bool retVal; parseStack.Push("boolean"); try { string s = node.FirstChild.Value; if (s == "1") { retVal = true; } else if (s == "0") { retVal = false; } else { throw new XmlRpcInvalidXmlRpcException( "reponse contains invalid boolean value " + StackDump(parseStack)); } } finally { parseStack.Pop(); } if (ValueType == typeof(XmlRpcBoolean)) return new XmlRpcBoolean(retVal); else return retVal; }
Object ParseArray( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { // required type must be an array if (ValueType != null && !(ValueType.IsArray == true || ValueType == typeof(Array) || ValueType == typeof(object))) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains array value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(ValueType) + " expected " + StackDump(parseStack)); } if (ValueType != null) { XmlRpcType xmlRpcType = XmlRpcServiceInfo.GetXmlRpcType(ValueType); if (xmlRpcType == XmlRpcType.tMultiDimArray) { parseStack.Push("array mapped to type " + ValueType.Name); Object ret = ParseMultiDimArray(node, ValueType, parseStack, mappingAction); return ret; } parseStack.Push("array mapped to type " + ValueType.Name); } else parseStack.Push("array"); XmlNode dataNode = node.SelectSingleNode("./data"); XmlNodeList childNodes = dataNode.SelectNodes("./value"); int nodeCount = childNodes.Count; Object[] elements = new Object[nodeCount]; // determine type of array elements Type elemType = null; if (ValueType != null && ValueType != typeof(Array) && ValueType != typeof(object)) { #if (!COMPACT_FRAMEWORK) elemType = ValueType.GetElementType(); #else string[] checkMultiDim = Regex.Split(ValueType.FullName, "\\[\\]$"); // determine assembly of array element type Assembly asmbly = ValueType.Assembly; string[] asmblyName = asmbly.FullName.Split(','); string elemTypeName = checkMultiDim[0] + ", " + asmblyName[0]; elemType = Type.GetType(elemTypeName); #endif } else { elemType = typeof(object); } bool bGotType = false; Type useType = null; int i = 0; foreach (XmlNode vNode in childNodes) { parseStack.Push(String.Format("element {0}", i)); XmlNode vvNode = vNode.SelectSingleNode("./*"); if (vvNode == null) vvNode = vNode.FirstChild; Type parsedType; Type parsedArrayType; elements[i++] = ParseValue(vvNode, elemType, parseStack, mappingAction, out parsedType, out parsedArrayType); if (bGotType == false) { useType = parsedArrayType; bGotType = true; } else { if (useType != parsedArrayType) useType = null; } parseStack.Pop(); } Object[] args = new Object[1]; args[0] = nodeCount; Object retObj = null; if (ValueType != null && ValueType != typeof(Array) && ValueType != typeof(object)) { retObj = CreateArrayInstance(ValueType, args); } else { if (useType == null) retObj = CreateArrayInstance(typeof(object[]), args); else retObj = CreateArrayInstance(useType, args); } for (int j=0; j < elements.Length; j++) { ((Array)retObj).SetValue(elements[j], j); } parseStack.Pop(); return retObj; }
void BuildArrayXml( XmlTextWriter xtw, Array ary, int CurRank, int[] indices, MappingAction mappingAction, ArrayList nestedObjs) { xtw.WriteStartElement("", "array", ""); xtw.WriteStartElement("", "data", ""); if (CurRank < (ary.Rank-1)) { for (int i=0; i<ary.GetLength(CurRank); i++) { indices[CurRank] = i; xtw.WriteStartElement("", "value", ""); BuildArrayXml(xtw, ary, CurRank+1, indices, mappingAction, nestedObjs); xtw.WriteEndElement(); } } else { for (int i=0; i<ary.GetLength(CurRank); i++) { indices[CurRank] = i; Serialize(xtw, ary.GetValue(indices), mappingAction, nestedObjs); } } xtw.WriteEndElement(); xtw.WriteEndElement(); }
Object ParseInt( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { if (ValueType != null && ValueType != typeof(Object) && ValueType != typeof(System.Int32) #if !FX1_0 && ValueType != typeof(int?) #endif && ValueType != typeof(XmlRpcInt)) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains int value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(ValueType) + " expected " + StackDump(parseStack)); } int retVal; parseStack.Push("integer"); try { XmlNode valueNode = node.FirstChild; if (valueNode == null) { throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType +" contains invalid int element " + StackDump(parseStack)); } try { String strValue = valueNode.Value; retVal = Int32.Parse(strValue); } catch(Exception) { throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains invalid int value " + StackDump(parseStack)); } } finally { parseStack.Pop(); } if (ValueType == typeof(XmlRpcInt)) return new XmlRpcInt(retVal); else return retVal; }
Object ParseHashtable( XmlNode node, Type valueType, ParseStack parseStack, MappingAction mappingAction) { XmlRpcStruct retObj = new XmlRpcStruct(); parseStack.Push("struct mapped to XmlRpcStruct"); try { XmlNodeList members = node.SelectNodes("./member"); foreach (XmlNode member in members) { if (member.Name != "member") continue; XmlNode nameNode; bool dupName; XmlNode valueNode; bool dupValue; SelectTwoNodes(member, "name", out nameNode, out dupName, "value", out valueNode, out dupValue); if (nameNode == null) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains a member with missing name element" + " " + StackDump(parseStack)); if (dupName) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains member with more than one name element" + " " + StackDump(parseStack)); string rpcName = nameNode.FirstChild.Value; if (valueNode == null) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains struct member " + rpcName + " with missing value " + " " + StackDump(parseStack)); if (dupValue) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains member with more than one value element" + " " + StackDump(parseStack)); if (retObj.Contains(rpcName)) { if (!IgnoreDuplicateMembers) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains struct value with duplicate member " + nameNode.FirstChild.Value + " " + StackDump(parseStack)); else continue; } object valObj; parseStack.Push(String.Format("member {0}", rpcName)); try { XmlNode vvNode = valueNode.SelectSingleNode("./*"); if (vvNode == null) vvNode = valueNode.FirstChild; valObj = ParseValue(vvNode, null, parseStack, mappingAction); } finally { parseStack.Pop(); } retObj.Add(rpcName, valObj); } } finally { parseStack.Pop(); } return retObj; }
XmlRpcFaultException ParseFault( XmlNode faultNode, ParseStack parseStack, MappingAction mappingAction) { XmlNode valueNode = faultNode.SelectSingleNode("./value"); XmlNode structNode = valueNode.SelectSingleNode("./struct"); if (structNode == null) { throw new XmlRpcInvalidXmlRpcException( "struct element missing from fault response."); } Fault fault; try { fault = (Fault)ParseValue(structNode, typeof(Fault), parseStack, mappingAction); } catch(Exception ex) { // some servers incorrectly return fault code in a string if (AllowStringFaultCode) throw; else { FaultStructStringCode faultStrCode; try { faultStrCode = (FaultStructStringCode)ParseValue(structNode, typeof(FaultStructStringCode), parseStack, mappingAction); fault.faultCode = Convert.ToInt32(faultStrCode.faultCode); fault.faultString = faultStrCode.faultString; } catch (Exception) { // use exception from when attempting to parse code as integer throw ex; } } } return new XmlRpcFaultException(fault.faultCode, fault.faultString); }
Object ParseDouble( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { if (ValueType != null && ValueType != typeof(Object) && ValueType != typeof(System.Double) #if !FX1_0 && ValueType != typeof(double?) #endif && ValueType != typeof(XmlRpcDouble)) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains double value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(ValueType) + " expected " + StackDump(parseStack)); } Double retVal; parseStack.Push("double"); try { retVal = Double.Parse(node.FirstChild.Value, CultureInfo.InvariantCulture.NumberFormat); } catch(Exception) { throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains invalid double value " + StackDump(parseStack)); } finally { parseStack.Pop(); } if (ValueType == typeof(XmlRpcDouble)) return new XmlRpcDouble(retVal); else return retVal; }
//#if (DEBUG) //#endif public void Serialize( XmlTextWriter xtw, Object o, MappingAction mappingAction) { Serialize(xtw, o, mappingAction, new ArrayList(16)); }
Object ParseMultiDimArray(XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { // parse the type name to get element type and array rank #if (!COMPACT_FRAMEWORK) Type elemType = ValueType.GetElementType(); int rank = ValueType.GetArrayRank(); #else string[] checkMultiDim = Regex.Split(ValueType.FullName, "\\[,[,]*\\]$"); Type elemType = Type.GetType(checkMultiDim[0]); string commas = ValueType.FullName.Substring(checkMultiDim[0].Length+1, ValueType.FullName.Length-checkMultiDim[0].Length-2); int rank = commas.Length+1; #endif // elements will be stored sequentially as nested arrays are parsed ArrayList elements = new ArrayList(); // create array to store length of each dimension - initialize to // all zeroes so that when parsing we can determine if an array for // that dimension has been parsed already int[] dimLengths = new int[rank]; dimLengths.Initialize(); ParseMultiDimElements(node, rank, 0, elemType, elements, dimLengths, parseStack, mappingAction); // build arguments to define array dimensions and create the array Object[] args = new Object[dimLengths.Length]; for (int argi=0; argi<dimLengths.Length; argi++) { args[argi] = dimLengths[argi]; } Array ret = (Array)CreateArrayInstance(ValueType, args); // copy elements into new multi-dim array //!! make more efficient int length = ret.Length; for (int e=0; e<length; e++) { int[] indices = new int[dimLengths.Length]; int div = 1; for (int f=(indices.Length-1); f>=0; f--) { indices[f] = (e/div)%dimLengths[f]; div*=dimLengths[f]; } ret.SetValue(elements[e], indices); } return ret; }
//#if (DEBUG) //#endif public void Serialize( XmlTextWriter xtw, Object o, MappingAction mappingAction, ArrayList nestedObjs) { if (nestedObjs.Contains(o)) throw new XmlRpcUnsupportedTypeException(nestedObjs[0].GetType(), "Cannot serialize recursive data structure"); nestedObjs.Add(o); try { xtw.WriteStartElement("", "value", ""); XmlRpcType xType = XmlRpcServiceInfo.GetXmlRpcType(o.GetType()); if (xType == XmlRpcType.tArray) { xtw.WriteStartElement("", "array", ""); xtw.WriteStartElement("", "data", ""); Array a = (Array) o; foreach (Object aobj in a) { if (aobj == null) throw new XmlRpcMappingSerializeException(String.Format( "Items in array cannot be null ({0}[]).", o.GetType().GetElementType())); Serialize(xtw, aobj, mappingAction, nestedObjs); } xtw.WriteEndElement(); xtw.WriteEndElement(); } else if (xType == XmlRpcType.tMultiDimArray) { Array mda = (Array)o; int[] indices = new int[mda.Rank]; BuildArrayXml(xtw, mda, 0, indices, mappingAction, nestedObjs); } else if (xType == XmlRpcType.tBase64) { byte[] buf = (byte[])o; xtw.WriteStartElement("", "base64", ""); xtw.WriteBase64(buf, 0, buf.Length); xtw.WriteEndElement(); } else if (xType == XmlRpcType.tBoolean) { bool boolVal; if (o is bool) boolVal = (bool)o; else boolVal = (bool)(XmlRpcBoolean)o; if (boolVal) xtw.WriteElementString("boolean", "1"); else xtw.WriteElementString("boolean", "0"); } else if (xType == XmlRpcType.tDateTime) { DateTime dt; if (o is DateTime) dt = (DateTime)o; else dt = (XmlRpcDateTime)o; string sdt = dt.ToString("yyyyMMdd'T'HH':'mm':'ss", DateTimeFormatInfo.InvariantInfo); xtw.WriteElementString("dateTime.iso8601", sdt); } else if (xType == XmlRpcType.tDouble) { double doubleVal; if (o is double) doubleVal = (double)o; else doubleVal = (XmlRpcDouble)o; xtw.WriteElementString("double", doubleVal.ToString(null, CultureInfo.InvariantCulture)); } else if (xType == XmlRpcType.tHashtable) { xtw.WriteStartElement("", "struct", ""); XmlRpcStruct xrs = o as XmlRpcStruct; foreach (object obj in xrs.Keys) { string skey = obj as string; xtw.WriteStartElement("", "member", ""); xtw.WriteElementString("name", skey); Serialize(xtw, xrs[skey], mappingAction, nestedObjs); xtw.WriteEndElement(); } xtw.WriteEndElement(); } else if (xType == XmlRpcType.tInt32) { if (UseIntTag) xtw.WriteElementString("int", o.ToString()); else xtw.WriteElementString("i4", o.ToString()); } else if (xType == XmlRpcType.tString) { if (UseStringTag) xtw.WriteElementString("string", (string)o); else xtw.WriteString((string)o); } else if (xType == XmlRpcType.tStruct) { MappingAction structAction = StructMappingAction(o.GetType(), mappingAction); xtw.WriteStartElement("", "struct", ""); MemberInfo[] mis = o.GetType().GetMembers(); foreach (MemberInfo mi in mis) { if (mi.MemberType == MemberTypes.Field) { FieldInfo fi = (FieldInfo)mi; string member = fi.Name; Attribute attrchk = Attribute.GetCustomAttribute(fi, typeof(XmlRpcMemberAttribute)); if (attrchk != null && attrchk is XmlRpcMemberAttribute) { string mmbr = ((XmlRpcMemberAttribute)attrchk).Member; if (mmbr != "") member = mmbr; } if (fi.GetValue(o) == null) { MappingAction memberAction = MemberMappingAction(o.GetType(), fi.Name, structAction); if (memberAction == MappingAction.Ignore) continue; throw new XmlRpcMappingSerializeException(@"Member """ + member + @""" of struct """ + o.GetType().Name + @""" cannot be null."); } xtw.WriteStartElement("", "member", ""); xtw.WriteElementString("name", member); Serialize(xtw, fi.GetValue(o), mappingAction, nestedObjs); xtw.WriteEndElement(); } else if (mi.MemberType == MemberTypes.Property) { PropertyInfo pi = (PropertyInfo)mi; string member = pi.Name; Attribute attrchk = Attribute.GetCustomAttribute(pi, typeof(XmlRpcMemberAttribute)); if (attrchk != null && attrchk is XmlRpcMemberAttribute) { string mmbr = ((XmlRpcMemberAttribute)attrchk).Member; if (mmbr != "") member = mmbr; } if (pi.GetValue(o, null) == null) { MappingAction memberAction = MemberMappingAction(o.GetType(), pi.Name, structAction); if (memberAction == MappingAction.Ignore) continue; } xtw.WriteStartElement("", "member", ""); xtw.WriteElementString("name", member); Serialize(xtw, pi.GetValue(o, null), mappingAction, nestedObjs); xtw.WriteEndElement(); } } xtw.WriteEndElement(); } else if (xType == XmlRpcType.tVoid) xtw.WriteElementString("string", ""); else throw new XmlRpcUnsupportedTypeException(o.GetType()); xtw.WriteEndElement(); } catch(System.NullReferenceException) { throw new XmlRpcNullReferenceException("Attempt to serialize data " + "containing null reference"); } finally { nestedObjs.RemoveAt(nestedObjs.Count - 1); } }
void ParseMultiDimElements(XmlNode node, int Rank, int CurRank, Type elemType, ArrayList elements, int[] dimLengths, ParseStack parseStack, MappingAction mappingAction) { if (node.Name != "array") { throw new XmlRpcTypeMismatchException( "param element does not contain array element."); } XmlNode dataNode = node.SelectSingleNode("./data"); XmlNodeList childNodes = dataNode.SelectNodes("./value"); int nodeCount = childNodes.Count; //!! check that multi dim array is not jagged if (dimLengths[CurRank] != 0 && nodeCount != dimLengths[CurRank]) { throw new XmlRpcNonRegularArrayException( "Multi-dimensional array must not be jagged."); } dimLengths[CurRank] = nodeCount; // in case first array at this rank if (CurRank < (Rank-1)) { foreach (XmlNode vNode in childNodes) { XmlNode arrayNode = vNode.SelectSingleNode("./array"); ParseMultiDimElements(arrayNode, Rank, CurRank+1, elemType, elements, dimLengths, parseStack, mappingAction); } } else { foreach (XmlNode vNode in childNodes) { XmlNode vvNode = vNode.SelectSingleNode("./*"); if (node == null) node = vNode.FirstChild; elements.Add(ParseValue(vvNode, elemType, parseStack, mappingAction)); } } }
MappingAction MemberMappingAction( Type type, string memberName, MappingAction currentAction) { // if struct member has mapping action attribute, override the current // mapping action else just return the current action if (type == null) return currentAction; Attribute attr = null; FieldInfo fi = type.GetField(memberName); if (fi != null) attr = Attribute.GetCustomAttribute(fi, typeof(XmlRpcMissingMappingAttribute)); else { PropertyInfo pi = type.GetProperty(memberName); attr = Attribute.GetCustomAttribute(pi, typeof(XmlRpcMissingMappingAttribute)); } if (attr != null) return ((XmlRpcMissingMappingAttribute)attr).Action; return currentAction; }
Object ParseString( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { if (ValueType != null && ValueType != typeof(System.String) && ValueType != typeof(Object)) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains string value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(ValueType) + " expected " + StackDump(parseStack)); } string ret; parseStack.Push("string"); try { if (node.FirstChild == null) ret = ""; else ret = node.FirstChild.Value; } finally { parseStack.Pop(); } return ret; }
Object ParseBase64( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { if (ValueType != null && ValueType != typeof(byte[]) && ValueType != typeof(Object)) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains base64 value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(ValueType) + " expected " + StackDump(parseStack)); } byte[] ret; parseStack.Push("base64"); try { if (node.FirstChild == null) ret = new byte[0]; else { string s = node.FirstChild.Value; try { ret = Convert.FromBase64String(s); } catch (Exception) { throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains invalid base64 value " + StackDump(parseStack)); } } } finally { parseStack.Pop(); } return ret; }
Object ParseStruct( XmlNode node, Type valueType, ParseStack parseStack, MappingAction mappingAction) { if (valueType.IsPrimitive) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains struct value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(valueType) + " expected " + StackDump(parseStack)); } #if !FX1_0 if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Nullable<>)) { valueType = valueType.GetGenericArguments()[0]; } #endif object retObj; try { retObj = Activator.CreateInstance(valueType); } catch (Exception ex) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains struct value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(valueType) + " expected (as type " + valueType.Name + ") " + StackDump(parseStack)); } // Note: mapping action on a struct is only applied locally - it // does not override the global mapping action when members of the // struct are parsed MappingAction localAction = mappingAction; if (valueType != null) { parseStack.Push("struct mapped to type " + valueType.Name); localAction = StructMappingAction(valueType, mappingAction); } else { parseStack.Push("struct"); } // create map of field names and remove each name from it as // processed so we can determine which fields are missing // TODO: replace HashTable with lighter collection Hashtable names = new Hashtable(); foreach (FieldInfo fi in valueType.GetFields()) { names.Add(fi.Name, fi.Name); } foreach (PropertyInfo pi in valueType.GetProperties()) { names.Add(pi.Name, pi.Name); } XmlNodeList members = node.SelectNodes("./member"); int fieldCount = 0; foreach (XmlNode member in members) { if (member.Name != "member") continue; XmlNode nameNode; bool dupName; XmlNode valueNode; bool dupValue; SelectTwoNodes(member, "name", out nameNode, out dupName, "value", out valueNode, out dupValue); if (nameNode == null) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains a member with missing name element" + " " + StackDump(parseStack)); if (dupName) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains member with more than one name element" + " " + StackDump(parseStack)); string name = nameNode.FirstChild.Value; if (valueNode == null) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains struct member " + name + " with missing value " + " " + StackDump(parseStack)); if (dupValue) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains member with more than one value element" + " " + StackDump(parseStack)); string structName = GetStructName(valueType, name); if (structName != null) name = structName; if (names.Contains(name)) names.Remove(name); else { if (!IgnoreDuplicateMembers && (valueType.GetField(name) != null || valueType.GetProperty(name) != null)) throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains struct value with duplicate member " + nameNode.FirstChild.Value + " " + StackDump(parseStack)); else continue; // ignore duplicate member } MemberInfo[] mis = valueType.GetMember(name); if (mis.Length == 0) { continue; // allow unexpected members } Object valObj = null; switch (mis[0].MemberType) { case MemberTypes.Field: FieldInfo fi = (FieldInfo)mis[0]; if (valueType == null) parseStack.Push(String.Format("member {0}", name)); else parseStack.Push(String.Format("member {0} mapped to type {1}", name,fi.FieldType.Name)); try { XmlNode vvvNode = valueNode.SelectSingleNode("./*"); if (vvvNode == null) vvvNode = valueNode.FirstChild; valObj = ParseValue(vvvNode, fi.FieldType, parseStack, mappingAction); } catch(XmlRpcInvalidXmlRpcException) { if (valueType != null && localAction == MappingAction.Error) { MappingAction memberAction = MemberMappingAction(valueType, name, MappingAction.Error); if (memberAction == MappingAction.Error) throw; } } finally { parseStack.Pop(); } fi.SetValue(retObj, valObj); break ; case MemberTypes.Property : PropertyInfo pi = (PropertyInfo)mis[0] ; if (valueType == null) parseStack.Push(String.Format("member {0}", name)); else parseStack.Push(String.Format("member {0} mapped to type {1}", name,pi.PropertyType.Name)); XmlNode vvNode = valueNode.SelectSingleNode("./*"); if (vvNode == null) vvNode = valueNode.FirstChild; valObj = ParseValue(vvNode, pi.PropertyType, parseStack, mappingAction); parseStack.Pop(); pi.SetValue(retObj, valObj, null); break ; } fieldCount++; } if (localAction == MappingAction.Error && names.Count > 0) ReportMissingMembers(valueType, names, parseStack); parseStack.Pop(); return retObj; }
Object ParseDateTime( XmlNode node, Type ValueType, ParseStack parseStack, MappingAction mappingAction) { if (ValueType != null && ValueType != typeof(Object) && ValueType != typeof(System.DateTime) #if !FX1_0 && ValueType != typeof(DateTime?) #endif && ValueType != typeof(XmlRpcDateTime)) { throw new XmlRpcTypeMismatchException(parseStack.ParseType + " contains dateTime.iso8601 value where " + XmlRpcServiceInfo.GetXmlRpcTypeString(ValueType) + " expected " + StackDump(parseStack)); } DateTime retVal; parseStack.Push("dateTime"); try { XmlNode child = node.FirstChild; if (child == null) { if (MapEmptyDateTimeToMinValue) return DateTime.MinValue; else throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains empty dateTime value " + StackDump(parseStack)); } string s = child.Value; try { // XML-RPC spec yyyyMMddThh:mm:ss string dateTimeFormat = "yyyyMMdd'T'HH':'mm':'ss"; if (AllowNonStandardDateTime) { if (s.IndexOf("T") == 8) { if (s.EndsWith("Z")) { // WordPress yyyyMMddThh:mm:ssZ dateTimeFormat = "yyyyMMdd'T'HH':'mm':'ss'Z'"; } else if (s.EndsWith("-00") || s.EndsWith("-0000") || s.EndsWith("+00") || s.EndsWith("+0000")) { s = s.Substring(0, 17); } } else { if (s.EndsWith("Z")) { // TypePad yyyy-MM-ddThh:mm:ssZ dateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"; } else { // other yyyy-MM-ddThh:mm:ss dateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss"; } } } if (MapZerosDateTimeToMinValue && s.StartsWith("0000") && (s == "00000000T00:00:00" || s == "0000-00-00T00:00:00Z" || s == "00000000T00:00:00Z" || s == "0000-00-00T00:00:00")) retVal = DateTime.MinValue; else retVal = DateTime.ParseExact(s, dateTimeFormat, DateTimeFormatInfo.InvariantInfo); } catch(Exception) { throw new XmlRpcInvalidXmlRpcException(parseStack.ParseType + " contains invalid dateTime value " + StackDump(parseStack)); } } finally { parseStack.Pop(); } if (ValueType == typeof(XmlRpcDateTime)) return new XmlRpcDateTime(retVal); else return retVal; }
public XmlRpcMissingMappingAttribute(MappingAction action) { _action = action; }