コード例 #1
0
ファイル: utils.cs プロジェクト: sgh1986915/vfos-scraper-c-
 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;
 }
コード例 #2
0
        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;
        }
コード例 #3
0
ファイル: SerializerConfig.cs プロジェクト: peteli/XmlRpc
 public SerializerConfig()
 {
     Indentation       = 2;
     NonStandard       = XmlRpcNonStandard.None;
     UseEmptyParamsTag = true;
     UseIndentation    = true;
     UseIntTag         = false;
     UseStringTag      = true;
     XmlEncoding       = null;
     MappingAction     = MappingAction.Error;
 }
コード例 #4
0
ファイル: XmlRpcDeserializer.cs プロジェクト: jackjet870/cms
 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; }));
 }
コード例 #5
0
ファイル: Utils.cs プロジェクト: magicmonty/xmlrpcnet
 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);
 }
コード例 #6
0
ファイル: utils.cs プロジェクト: wbrussell/xmlrpcnet
 //----------------------------------------------------------------------// 
 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);
 }
コード例 #7
0
        /// <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));
        }
コード例 #8
0
        //----------------------------------------------------------------------//
        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));
        }
コード例 #9
0
        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));
        }
コード例 #10
0
        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);
        }
コード例 #11
0
ファイル: utils.cs プロジェクト: wbrussell/xmlrpcnet
 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;
 }
コード例 #12
0
        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));
        }
コード例 #13
0
        //----------------------------------------------------------------------//
        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));
        }
コード例 #14
0
        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);
        }
コード例 #15
0
        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");
            }
        }
コード例 #16
0
ファイル: utils.cs プロジェクト: sgh1986915/vfos-scraper-c-
 //----------------------------------------------------------------------// 
 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);
 }
コード例 #17
0
        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);
        }
コード例 #18
0
        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);
        }
コード例 #19
0
ファイル: utils.cs プロジェクト: sgh1986915/vfos-scraper-c-
 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;
 }
コード例 #20
0
 /// <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);
 }
コード例 #21
0
        //----------------------------------------------------------------------//
        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));
        }
コード例 #22
0
        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();
        }
コード例 #23
0
        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);
        }
コード例 #24
0
        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);
        }
コード例 #25
0
        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);
        }
コード例 #26
0
ファイル: utils.cs プロジェクト: sgh1986915/vfos-scraper-c-
 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();
 }
コード例 #27
0
ファイル: Utils.cs プロジェクト: magicmonty/xmlrpcnet
 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);
 }
コード例 #28
0
        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);
            }
        }
コード例 #29
0
        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));
        }
コード例 #30
0
        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();
        }
コード例 #31
0
        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);
        }
コード例 #32
0
        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));
        }
コード例 #33
0
        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());
        }
コード例 #34
0
 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));
         }
     }));
 }
コード例 #35
0
        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);
        }
コード例 #36
0
        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);

        }
コード例 #37
0
 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;
     }));
 }
コード例 #38
0
 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;
     }));
 }
コード例 #39
0
        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);
   }
コード例 #43
0
 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;
   }
コード例 #60
0
 public XmlRpcMissingMappingAttribute(MappingAction action)
 {
     _action = action;
 }