SoapCommonClasses.ParseRecord

1. // ==++==
2. // 
3. //   
4. //    Copyright (c) 2002 Microsoft Corporation.  All rights reserved.
5. //   
6. //    The use and distribution terms for this software are contained in the file
7. //    named license.txt, which can be found in the root of this distribution.
8. //    By using this software in any fashion, you are agreeing to be bound by the
9. //    terms of this license.
10. //   
11. //    You must not remove this notice, or any other, from this software.
12. //   
13. // 
14. // ==--==
15. //============================================================
16. //
17. // Class: SoapCommonClasses
18. //       
19. // Purpose: utility classes
20. //
21. // Date:  June 10, 1999
22. //
23. //============================================================
25. namespace System.Runtime.Serialization.Formatters.Soap
26. {
27.     using System;
28.     using System.Collections;
29.     using System.Reflection;
30.     using System.Text;
31.     using System.Globalization;
32.     using System.Runtime.Serialization.Formatters;
33.     using System.Runtime.Remoting;
34.     using System.Runtime.Remoting.Metadata;
35.     using System.Runtime.Remoting.Messaging;
36.     using System.Runtime.InteropServices;
37.     using System.Runtime.Serialization;
38.     using System.Resources;
39.     using System.Diagnostics;
41.     // AttributeList class is used to transmit attributes from XMLObjectWriter to XMLWriter
42.     internal sealed class AttributeList
43.     {
44.         private SerStack nameA = new SerStack("AttributeName");
45.         private SerStack valueA = new SerStack("AttributeValue");
47.         internal int Count
48.         {
49.             get {return nameA.Count();}
50.         }
52.         internal void Clear()
53.         {
54.             nameA.Clear();
55.             valueA.Clear();            
56.         }
58.         internal void Put(String name, String value)
59.         {
60.             nameA.Push(name);
61.             valueA.Push(value);
62.         }
64.         internal void Get(int index, out String name, out String value)
65.         {
66.             name = (String)nameA.Next();
67.             value = (String)valueA.Next();
68.         }
70.         [Conditional("SER_LOGGING")]                            
71.         internal void Dump()
72.         {
73.             nameA.Dump();
74.             valueA.Dump();
75.         }
76.     }
78.     // Implements a stack used for parsing
80.     internal sealed class SerStack
81.     {
82.         //internal ArrayList stack = new ArrayList(10);
83.         internal Object[] objects = new Object[10];
84.         internal String stackId;
85.         internal int top = -1;
86.         internal int next = 0;
88.         internal SerStack()
89.         {
90.             stackId = "System";
91.         }
93.         internal SerStack(String stackId) {
94.             this.stackId = stackId;
95.         }
97.         internal Object GetItem(int index)
98.         {
99.             return objects[index];
100.         }
102.         internal void Clear()
103.         {
104.             top = -1;
105.             next = 0;
106.         }
108.         // Push the object onto the stack
109.         internal void Push(Object obj) {
110.             InternalST.Soap(this, "Push ",stackId," ",((obj is ITrace)?((ITrace)obj).Trace():""));                                    
111.             if (top == (objects.Length -1)) {
112.                 IncreaseCapacity();
113.             }
114.             objects[++top] = obj;        
115.         }
117.         // Pop the object from the stack
118.         internal Object Pop() {
119.             if (top < 0)
120.                 return null;
122.             Object obj = objects[top];
123.             objects[top--] = null;
124.             InternalST.Soap(this, "Pop ",stackId," ",((obj is ITrace)?((ITrace)obj).Trace():""));            
125.             return obj;
126.         }
128.         internal Object Next()
129.         {
130.             if (next > top)
131.                 throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_StackRange"),stackId));                
132.             return objects[next++];
133.         }
135.         internal void IncreaseCapacity() {
136.             int size = objects.Length * 2;
137.             Object[] newItems = new Object[size];
138.             Array.Copy(objects, 0, newItems, 0, objects.Length);
139.             objects = newItems;
140.         }
142.         // Gets the object on the top of the stack
143.         internal Object Peek() {
144.             if (top < 0)
145.                 return null;        
146.             InternalST.Soap(this, "Peek ",stackId," ",((objects[top] is ITrace)?((ITrace)objects[top]).Trace():""));            
147.             return objects[top];
148.         }
150.         // Gets the second entry in the stack.
151.         internal Object PeekPeek() {
152.             if (top < 1)
153.                 return null;
154.             InternalST.Soap(this, "PeekPeek ",stackId," ",((objects[top - 1] is ITrace)?((ITrace)objects[top - 1]).Trace():""));                                    
155.             return objects[top - 1];        
156.         }
158.         // The number of entries in the stack
159.         internal int Count() {
160.             return top + 1; 
161.         }
163.         // The number of entries in the stack
164.         internal bool IsEmpty() {
165.             if (top > 0) 
166.                 return false;
167.             else
168.                 return true;
169.         }
171.         // Reverse the stack
172.         internal void Reverse() {
173.             Array.Reverse(objects, 0, Count());
174.         }
176.         [Conditional("SER_LOGGING")]                                
177.         internal void Dump()
178.         {
179.             for (int i=0; i<Count(); i++)
180.             {
181.                 Object obj = objects[i];
182.                 InternalST.Soap(this, "Stack Dump ",stackId," "+((obj is ITrace)?((ITrace)obj).Trace():""));                                        
183.             }
184.         }
185.     }
188.     internal sealed class NameCacheEntry
189.     {
190.         internal String name;
191.         internal Object value;
192.     }
195.     internal sealed class NameCache
196.     {
197.         private const int MAX_CACHE_ENTRIES = 353; // Needs to be a prime number
198.         static NameCacheEntry[] nameCache = new NameCacheEntry[MAX_CACHE_ENTRIES];
200.         int probe = 0;
201.         String name = null;
203.         internal Object GetCachedValue(String name)
204.         {
205.             this.name = name;
206.             probe = Math.Abs(name.GetHashCode())%MAX_CACHE_ENTRIES;
207.             NameCacheEntry entry = nameCache[probe];
208.             if (entry == null)
209.             {
210.                 entry = new NameCacheEntry();
211.                 entry.name = name;
212.                 return null;
213.             }
214.             else if (entry.name == name)
215.             {
216.                 return entry.value;
217.             }
218.             else
219.                 return null;
220.         }
222.         internal void SetCachedValue(Object value)
223.         {
224.             NameCacheEntry entry = new NameCacheEntry();
225.             entry.name = name;
226.             entry.value = value;
227.             nameCache[probe] = entry;
228.         }
229.     }
233.     internal sealed class SoapUtil
234.     {
235.         internal static Type typeofString = typeof(String);
236.         internal static Type typeofBoolean = typeof(Boolean);
237.         internal static Type typeofObject = typeof(Object);
238.         internal static Type typeofSoapFault = typeof(SoapFault);        
239.         internal static Assembly urtAssembly = Assembly.GetAssembly(typeofString);
240.         internal static String urtAssemblyString = urtAssembly.FullName;
242.         [Conditional("SER_LOGGING")]        
243.         internal static void DumpHash(String tag, Hashtable hashTable)
244.         {
245.             IDictionaryEnumerator e = hashTable.GetEnumerator();
246.             InternalST.Soap("HashTable Dump Begin ", tag);
247.             while(e.MoveNext())
248.             {
249.                 InternalST.Soap("HashTable key "+e.Key+", value "+e.Value);
250.             }
251.             InternalST.Soap("HashTable Dump end /n");            
252.         }
254.         
255.         internal static ResourceManager SystemResMgr;
257.         private static ResourceManager InitResourceManager()
258.         {
259.             if (SystemResMgr == null)
260.                 SystemResMgr = new ResourceManager("SoapFormatter", typeof(SoapParser).Module.Assembly);
261.             return SystemResMgr;
262.         }
264.         // Looks up the resource string value for key.
265.         // 
266.         internal static String GetResourceString(String key)
267.         {
268.             if (SystemResMgr == null)
269.                 InitResourceManager();
270.             String s = SystemResMgr.GetString(key, null);
271.             InternalST.SoapAssert(s!=null, "Managed resource string lookup failed.  Was your resource name misspelled?  Did you rebuild the SoapFormatter and SoapFormatter.resource after adding a resource to SoapFormatter.txt?  Debug this w/ cordbg and bug whoever owns the code that called SoapUtil.GetResourceString.  Resource name was: /""+key+"/"");
272.             return s;
273.         }
275.         internal static String GetResourceString(String key, params Object[] values) {
276.             if (SystemResMgr == null)
277.                 InitResourceManager();
278.             String s = SystemResMgr.GetString(key, null);
279.             InternalST.SoapAssert(s!=null, "Managed resource string lookup failed.  Was your resource name misspelled?  Did you rebuild mscorlib after adding a resource to resources.txt?  Debug this w/ cordbg and bug whoever owns the code that called Environment.GetResourceString.  Resource name was: /""+key+"/"");
280.             return String.Format(s, values);
281.         }
282.     }
284.     internal sealed class SoapAssemblyInfo
285.     {
286.         internal String assemblyString;
287.         private Assembly assembly;
289.         internal SoapAssemblyInfo(String assemblyString)
290.         {
291.             this.assemblyString = assemblyString;
292.         }
294.         internal SoapAssemblyInfo(String assemblyString, Assembly assembly)
295.         {
296.             this.assemblyString = assemblyString;
297.             this.assembly = assembly;
298.         }
300.         internal Assembly GetAssembly(ObjectReader objectReader)
301.         {
302.             if (assembly == null)
303.             {
304.                 assembly = objectReader.LoadAssemblyFromString(assemblyString);
305.                 if (assembly == null)
306.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_AssemblyString"),assemblyString));
307.             }
308.             return assembly;
309.         }
310.     }
312.     // The ParseRecord class holds the parsed XML information. There is a
313.     // ParsedRecord for each XML Element
314.     internal sealed class ParseRecord : ITrace
315.     {
316.         internal static int parseRecordIdCount = 1;
319.         internal int PRparseRecordId = 0;
321.         // Enums
322.         internal InternalParseTypeE PRparseTypeEnum = InternalParseTypeE.Empty;
323.         internal InternalObjectTypeE PRobjectTypeEnum = InternalObjectTypeE.Empty;
324.         internal InternalArrayTypeE PRarrayTypeEnum = InternalArrayTypeE.Empty;
325.         internal InternalMemberTypeE PRmemberTypeEnum = InternalMemberTypeE.Empty;
326.         internal InternalMemberValueE PRmemberValueEnum = InternalMemberValueE.Empty;
327.         internal InternalObjectPositionE PRobjectPositionEnum = InternalObjectPositionE.Empty;
329.         // Object
330.         internal String PRname;
331.         internal String PRnameXmlKey;
332.         internal String PRxmlNameSpace;
333.         internal bool PRisParsed = false;
334.         internal bool PRisProcessAttributes = false;
336.         // Value
337.         internal String PRvalue;
338.         internal Object PRvarValue;
340.         // dt attribute
341.         internal String PRkeyDt;
342.         internal String PRtypeXmlKey;
343.         internal Type PRdtType;
344.         internal String PRassemblyName;
345.         internal InternalPrimitiveTypeE PRdtTypeCode;
346.         internal bool PRisVariant = false; // Used by Binary
347.         internal bool PRisEnum = false;
349.         // Object ID
350.         internal long PRobjectId;
352.         // Reference ID
353.         internal long PRidRef;
355.         // Array
357.         // Array Element Type
358.         internal String PRarrayElementTypeString;
359.         internal Type PRarrayElementType;
360.         internal bool PRisArrayVariant = false;
361.         internal InternalPrimitiveTypeE PRarrayElementTypeCode;
362.         //internal String PRarrayXmlKey;
364.         // Binary Byte Array
365.         //internal Byte[] PRbyteA;
367.         // Array Primitive Element type
368.         internal String PRprimitiveArrayTypeString;
370.         // Parsed array information
371.         internal int PRrank;
372.         internal int[] PRlengthA;
373.         internal int[] PRpositionA;
374.         internal int[] PRlowerBoundA;
375.         internal int[] PRupperBoundA;
377.         // Array map for placing array elements in array
378.         //internal int[][] indexMap;
379.         internal int[] PRindexMap; 
380.         internal int PRmemberIndex;
381.         internal int PRlinearlength;
382.         internal int[] PRrectangularMap;
383.         internal bool    PRisLowerBound;
385.         // SerializedStreamHeader information
386.         internal long PRtopId;
387.         internal long PRheaderId;
388.         internal bool PRisHeaderRoot;
389.         internal bool PRisAttributesProcessed;
391.         // Parsed HeaderMember Information
392.         internal bool PRisMustUnderstand;
395.         // Parse State
396.         internal InternalParseStateE PRparseStateEnum = InternalParseStateE.Initial;
397.         internal bool PRisWaitingForNestedObject = false;
399.         // MemberInfo accumulated during parsing of members
401.         internal ReadObjectInfo PRobjectInfo;
403.         // ValueType Fixup needed
404.         internal bool PRisValueTypeFixup = false;
406.         // Created object
407.         internal Object PRnewObj;
408.         internal Object[] PRobjectA; //optimization, will contain object[]
409.         internal PrimitiveArray PRprimitiveArray; // for Primitive Soap arrays, optimization
410.         internal bool PRisRegistered; // Used when registering nested classes
412.         internal bool PRisXmlAttribute;
415.         internal ParseRecord()
416.         {
417.             Counter();
418.         }
420.         private void Counter()
421.         {
422.             // The counter is used to test parseRecord identity
423.             lock(typeof(ParseRecord))
424.             {
425.                 PRparseRecordId = parseRecordIdCount++;
426.             }
428.         }
431.         // Get a String describing the ParseRecord
433.         public String Trace()
434.         {
435.             //return "ParseType "+EnumInfo.ToString(InternalParseTypeE.class, parseTypeEnum)+" name "+name+" ParseState "+EnumInfo.ToString(InternalParseStateE.class, parseStateEnum);
436.             return "ParseRecord"+PRparseRecordId+" ParseType "+ ((Enum)PRparseTypeEnum).ToString() +" name "+PRname+" keyDt "+Util.PString(PRkeyDt);
437.         }
439.         // Initialize ParseRecord. Called when reusing.
440.         internal void Init()
441.         {
442.             // Enums
443.             PRparseTypeEnum = InternalParseTypeE.Empty;
444.             PRobjectTypeEnum = InternalObjectTypeE.Empty;
445.             PRarrayTypeEnum = InternalArrayTypeE.Empty;
446.             PRmemberTypeEnum = InternalMemberTypeE.Empty;
447.             PRmemberValueEnum = InternalMemberValueE.Empty;
448.             PRobjectPositionEnum = InternalObjectPositionE.Empty;
450.             // Object
451.             PRname = null;
452.             PRnameXmlKey = null;
453.             PRxmlNameSpace = null;
454.             PRisParsed = false;
455.             PRisProcessAttributes = false;
457.             // Value
458.             PRvalue = null;
460.             // dt attribute
461.             PRkeyDt = null;
462.             PRdtType = null;
463.             PRassemblyName = null;
464.             PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
465.             PRisEnum = false;            
467.             // Object ID
468.             PRobjectId = 0;
470.             // Reference ID
471.             PRidRef = 0;
473.             // Array
475.             // Array Element Type
476.             PRarrayElementTypeString = null;
477.             PRarrayElementType = null;
478.             PRisArrayVariant = false;
479.             PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
482.             // Array Primitive Element type
483.             PRprimitiveArrayTypeString = null;
485.             // Parsed array information
486.             PRrank = 0;
487.             PRlengthA = null;
488.             PRpositionA = null;
489.             PRlowerBoundA = null;
490.             PRupperBoundA = null;        
492.             // Array map for placing array elements in array
493.             PRindexMap = null;
494.             PRmemberIndex = 0;
495.             PRlinearlength = 0;
496.             PRrectangularMap = null;
497.             PRisLowerBound = false;
499.             // SerializedStreamHeader information
500.             PRtopId = 0;
501.             PRheaderId = 0;
502.             PRisHeaderRoot = false;
503.             PRisAttributesProcessed = false;
505.             // Parsed HeaderMember Information
506.             PRisMustUnderstand = false;
508.             // Parse State
509.             PRparseStateEnum = InternalParseStateE.Initial;
510.             PRisWaitingForNestedObject = false;
513.             // ValueType Fixup needed
514.             PRisValueTypeFixup = false;
516.             PRnewObj = null;
517.             PRobjectA = null;
518.             PRprimitiveArray = null;            
519.             PRobjectInfo = null;
520.             PRisRegistered = false;
522.             PRisXmlAttribute = false;
523.         }
525.         internal ParseRecord Copy()
526.         {
528.             ParseRecord newPr = new ParseRecord();
529.             // Enums
530.             newPr.PRparseTypeEnum = PRparseTypeEnum;
531.             newPr.PRobjectTypeEnum = PRobjectTypeEnum;
532.             newPr.PRarrayTypeEnum = PRarrayTypeEnum;
533.             newPr.PRmemberTypeEnum = PRmemberTypeEnum;
534.             newPr.PRmemberValueEnum = PRmemberValueEnum;
535.             newPr.PRobjectPositionEnum = PRobjectPositionEnum;
537.             // Object
538.             newPr.PRname = PRname;
539.             newPr.PRisParsed = PRisParsed;            
540.             newPr.PRisProcessAttributes = PRisProcessAttributes;
541.             newPr.PRnameXmlKey = PRnameXmlKey;
542.             newPr.PRxmlNameSpace = PRxmlNameSpace;            
544.             // Value
545.             newPr.PRvalue = PRvalue;
548.             // dt attribute
549.             newPr.PRkeyDt = PRkeyDt;
550.             newPr.PRdtType = PRdtType;
551.             newPr.PRassemblyName = PRassemblyName;
552.             newPr.PRdtTypeCode = PRdtTypeCode;
553.             newPr.PRisEnum = PRisEnum;            
555.             // Object ID
556.             newPr.PRobjectId = PRobjectId;
558.             // Reference ID
559.             newPr.PRidRef = PRidRef;
561.             // Array
563.             // Array Element Type
564.             newPr.PRarrayElementTypeString = PRarrayElementTypeString;
565.             newPr.PRarrayElementType = PRarrayElementType;
566.             newPr.PRisArrayVariant = PRisArrayVariant;
567.             newPr.PRarrayElementTypeCode = PRarrayElementTypeCode;
570.             // Array Primitive Element type
571.             newPr.PRprimitiveArrayTypeString = PRprimitiveArrayTypeString;
573.             // Parsed array information
574.             newPr.PRrank = PRrank;
575.             newPr.PRlengthA = PRlengthA;
576.             newPr.PRpositionA = PRpositionA;
577.             newPr.PRlowerBoundA = PRlowerBoundA;
578.             newPr.PRupperBoundA = PRupperBoundA;        
580.             // Array map for placing array elements in array
581.             newPr.PRindexMap = PRindexMap;
582.             newPr.PRmemberIndex = PRmemberIndex;
583.             newPr.PRlinearlength = PRlinearlength;
584.             newPr.PRrectangularMap = PRrectangularMap;
585.             newPr.PRisLowerBound = PRisLowerBound;
587.             // SerializedStreamHeader information
588.             newPr.PRtopId = PRtopId;
589.             newPr.PRheaderId = PRheaderId;
590.             newPr.PRisHeaderRoot = PRisHeaderRoot;
591.             newPr.PRisAttributesProcessed = PRisAttributesProcessed;
593.             // Parsed HeaderMember Information
594.             newPr.PRisMustUnderstand = PRisMustUnderstand;
596.             // Parse State
597.             newPr.PRparseStateEnum = PRparseStateEnum;
598.             newPr.PRisWaitingForNestedObject = PRisWaitingForNestedObject;
601.             // ValueType Fixup needed
602.             newPr.PRisValueTypeFixup = PRisValueTypeFixup;
604.             newPr.PRnewObj = PRnewObj;
605.             newPr.PRobjectA = PRobjectA;
606.             newPr.PRprimitiveArray = PRprimitiveArray;
607.             newPr.PRobjectInfo = PRobjectInfo;
608.             newPr.PRisRegistered = PRisRegistered;
609.             newPr.PRisXmlAttribute = PRisXmlAttribute;
611.             return newPr;
612.         }        
615.         // Dump ParseRecord. 
616.         [Conditional("SER_LOGGING")]                                
617.         internal void Dump()
618.         {
619.             InternalST.Soap("ParseRecord Dump ",PRparseRecordId);
620.             InternalST.Soap("Enums");
621.             Util.NVTrace("ParseType",((Enum)PRparseTypeEnum).ToString());
622.             Util.NVTrace("ObjectType",((Enum)PRobjectTypeEnum).ToString());
623.             Util.NVTrace("ArrayType",((Enum)PRarrayTypeEnum).ToString());
624.             Util.NVTrace("MemberType",((Enum)PRmemberTypeEnum).ToString());
625.             Util.NVTrace("MemberValue",((Enum)PRmemberValueEnum).ToString());
626.             Util.NVTrace("ObjectPosition",((Enum)PRobjectPositionEnum).ToString());
627.             Util.NVTrace("ParseState",((Enum)PRparseStateEnum).ToString());                
628.             InternalST.Soap("Basics");        
629.             Util.NVTrace("Name",PRname);
630.             Util.NVTrace("PRisParsed", PRisParsed);
631.             Util.NVTrace("PRisProcessAttributes", PRisParsed);
632.             Util.NVTrace("PRnameXmlKey",PRnameXmlKey);
633.             Util.NVTrace("PRxmlNameSpace", PRxmlNameSpace);        
634.             Util.NVTrace("Value ",PRvalue);
635.             Util.NVTrace("varValue ",PRvarValue);
636.             if (PRvarValue != null)
637.                 Util.NVTrace("varValue type",PRvarValue.GetType());                
639.             Util.NVTrace("keyDt",PRkeyDt);
640.             Util.NVTrace("dtType",PRdtType);
641.             Util.NVTrace("assemblyName",PRassemblyName);
642.             Util.NVTrace("code",((Enum)PRdtTypeCode).ToString());
643.             Util.NVTrace("objectID",PRobjectId);
644.             Util.NVTrace("idRef",PRidRef);
645.             Util.NVTrace("isEnum",PRisEnum);            
646.             InternalST.Soap("Array ");
647.             Util.NVTrace("arrayElementTypeString",PRarrayElementTypeString);
648.             Util.NVTrace("arrayElementType",PRarrayElementType);
649.             Util.NVTrace("arrayElementTypeCode",((Enum)PRarrayElementTypeCode).ToString());        
650.             Util.NVTrace("isArrayVariant",PRisArrayVariant);
651.             Util.NVTrace("primitiveArrayTypeString",PRprimitiveArrayTypeString);
652.             Util.NVTrace("rank",PRrank);
653.             Util.NVTrace("dimensions", Util.PArray(PRlengthA));
654.             Util.NVTrace("position", Util.PArray(PRpositionA));
655.             Util.NVTrace("lowerBoundA", Util.PArray(PRlowerBoundA));
656.             Util.NVTrace("upperBoundA", Util.PArray(PRupperBoundA));        
657.             InternalST.Soap("Header ");        
658.             Util.NVTrace("isMustUnderstand", PRisMustUnderstand);
659.             Util.NVTrace("isHeaderRoot", PRisHeaderRoot);
660.             Util.NVTrace("isAttributesProcessed", PRisAttributesProcessed);
661.             Util.NVTrace("isXmlAttribute", PRisXmlAttribute);
663.             InternalST.Soap("New Object");
664.             if (PRnewObj != null)
665.                 Util.NVTrace("newObj", PRnewObj);
666.             /*
667.             if ((objectInfo != null) && (objectInfo.objectType != null))
668.             Util.NVTrace("objectInfo", objectInfo.objectType.ToString());
669.             */
670.         }
671.     }
673.     internal interface ITrace
674.     {
675.         String Trace();
676.     }
678.     // Utilities
679.     internal sealed class Util
680.     {
681.         
682.         // Replaces a null string with an empty string
683.         internal static String PString(String value)
684.         {
685.             if (value == null)
686.                 return "";
687.             else
688.                 return value;
689.         }
691.         // Converts an object to a string and checks for nulls
692.         internal static String PString(Object value)
693.         {
694.             if (value == null)
695.                 return "";
696.             else
697.                 return value.ToString();
698.         }
700.         // Converts a single int array to a string
702.         internal static String PArray(int[] array)
703.         {
704.             if (array != null)
705.             {
706.                 StringBuilder sb = new StringBuilder(10);
707.                 sb.Append("[");        
708.                 for (int i=0; i<array.Length; i++)
709.                 {
710.                     sb.Append(array[i]);
711.                     if (i != array.Length -1)
712.                         sb.Append(",");
713.                 }
714.                 sb.Append("]");
715.                 return sb.ToString();
716.             }
717.             else
718.                 return "";
719.         }
722.         // Traces a name value pair
724.         [Conditional("SER_LOGGING")]                                
725.         internal static void NVTrace(String name, String value)
726.         {
727.             InternalST.Soap("  "+name+((value == null)?" = null":" = "+value));
728.         }
730.         // Traces a name value pair
731.         [Conditional("SER_LOGGING")]                                        
732.         internal static void NVTrace(String name, Object value)
733.         {
734.             try {
735.             InternalST.Soap("  "+name+((value == null)?" = null":" = "+value.ToString()));            
736.             }catch(Exception)
737.             {
738.                 InternalST.Soap("  "+name+" = null"); //Empty StringBuilder is giving an exception
739.             }
740.         }
742.         // Traces a name value pair
744.         [Conditional("_LOGGING")]                                
745.         internal static void NVTraceI(String name, String value)
746.         {
747.             InternalST.Soap("  "+name+((value == null)?" = null":" = "+value));            
748.         }
750.         // Traces a name value pair
751.         [Conditional("_LOGGING")]                                        
752.         internal static void NVTraceI(String name, Object value)
753.         {
754.             InternalST.Soap("  "+name+((value == null)?" = null":" = "+value.ToString()));            
755.         }
757.     }
760.     // Used to fixup value types. Only currently used for value types which are array items.
761.     internal class ValueFixup : ITrace
762.     {
763.         internal ValueFixupEnum valueFixupEnum = ValueFixupEnum.Empty;
764.         internal Array arrayObj;
765.         internal int[] indexMap;
766.         internal Object header;
767.         internal Object memberObject;
768.         internal static MemberInfo valueInfo;
769.         internal ReadObjectInfo objectInfo;
770.         internal String memberName;
772.         internal ValueFixup(Array arrayObj, int[] indexMap)
773.         {
774.             InternalST.Soap(this, "Array Constructor ",arrayObj);                                        
775.             valueFixupEnum = ValueFixupEnum.Array;
776.             this.arrayObj = arrayObj;
777.             this.indexMap = indexMap;
778.         }
780.         internal ValueFixup(Object header)
781.         {
782.             InternalST.Soap(this, "Header Constructor ",header);                                                
783.             valueFixupEnum = ValueFixupEnum.Header;
784.             this.header = header;
785.         }
787.         internal ValueFixup(Object memberObject, String memberName, ReadObjectInfo objectInfo)
788.         {
789.             InternalST.Soap(this, "Member Constructor ",memberObject);                                                
790.             valueFixupEnum = ValueFixupEnum.Member;
791.             this.memberObject = memberObject;
792.             this.memberName = memberName;
793.             this.objectInfo = objectInfo;
794.         }
796.         internal virtual void Fixup(ParseRecord record, ParseRecord parent)
797.         {
798.             Object obj = record.PRnewObj;
799.             InternalST.Soap(this, "Fixup ",obj," ",((Enum)valueFixupEnum).ToString());
801.             switch(valueFixupEnum)
802.             {
803.                 case ValueFixupEnum.Array:
804.                     arrayObj.SetValue(obj, indexMap);
805.                     break;
806.                 case ValueFixupEnum.Header:
807.                     Type type = typeof(Header);
808.                     if (valueInfo == null)
809.                     {
810.                         MemberInfo[] valueInfos = type.GetMember("Value");
811.                         if (valueInfos.Length != 1)
812.                             throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_HeaderReflection"),valueInfos.Length));                                                                                
813.                         valueInfo = valueInfos[0];
814.                     }
815.                     InternalST.SerializationSetValue((FieldInfo)valueInfo, header, obj);
816.                     break;
817.                 case ValueFixupEnum.Member:
819.                     InternalST.Soap(this, "Fixup Member new object value ",obj," memberObject ",memberObject);
821.                     if (objectInfo.isSi) {
822.                         InternalST.Soap(this, "Recording a fixup on member: ", memberName, 
823.                                      " in object id", parent.PRobjectId, " Required Object ", record.PRobjectId);
824.                         objectInfo.objectManager.RecordDelayedFixup(parent.PRobjectId, memberName, record.PRobjectId);
825.                     } else {
826.                         MemberInfo memberInfo = objectInfo.GetMemberInfo(memberName);
827.                         InternalST.Soap(this, "Recording a fixup on member:", memberInfo, " in object id ", 
828.                                      parent.PRobjectId," Required Object", record.PRobjectId);
829.                         objectInfo.objectManager.RecordFixup(parent.PRobjectId, memberInfo, record.PRobjectId);
830.                     }
831.                     break;
832.             }
833.         }
835.         public virtual String Trace()
836.         {
837.             return "ValueFixup"+((Enum)valueFixupEnum).ToString();
838.         }
840.     }
842.     // Class used to transmit Enums from the XML and Binary Formatter class to the ObjectWriter and ObjectReader class
843.     internal sealed class InternalFE
844.     {
845.         internal FormatterTypeStyle FEtypeFormat;
846.         internal FormatterAssemblyStyle FEassemblyFormat;
847.         internal ISoapMessage FEtopObject;
848.         internal InternalSerializerTypeE FEserializerTypeEnum;
849.     }
851.     // Class used to Read an XML record which has a fake object as the top object.
852.     // A fake object is an object which has the methodName as the XML elementName rather
853.     // then a valid object name.
854.     // After the information is read a SoapMessage object is created as the top object
855.     // to return the information as the top object graph
856.     [Serializable]    
857.     internal sealed class InternalSoapMessage : ISerializable, IFieldInfo
858.     {
859.         internal String methodName = null;
860.         internal String xmlNameSpace = null;
861.         internal String[] paramNames = null;
862.         internal Object[] paramValues = null;
863.         internal Type[] paramTypes = null;
864.         internal Hashtable keyToNamespaceTable = null;
866.         // Read Constructor
867.         internal InternalSoapMessage()
868.         {
869.             InternalST.Soap(this, "Constructor Read  Unitialized ");
870.         }
872.         // Write Constructor
873.         internal InternalSoapMessage(String methodName, String xmlNameSpace, String[] paramNames, Object[] paramValues, Type[] paramTypes)
874.         {
875.             InternalST.Soap(this, "Constructor Write ",methodName);
876.             this.methodName = methodName;
877.             this.xmlNameSpace = xmlNameSpace;
878.             this.paramNames = paramNames;
879.             this.paramValues = paramValues;
880.             this.paramTypes = paramTypes;
881.         }
883.         internal InternalSoapMessage(SerializationInfo info, StreamingContext context)
884.         {
885.             InternalST.Soap(this, "Constructor Write  SetObjectData ");            
886.             SetObjectData(info, context);
887.         }
889.         // IFieldInfo 
890.         public String[] FieldNames
891.         {
892.             get {return paramNames;}
893.             set {paramNames = value;}
894.         }
896.         // IFieldInfo         
897.         public Type[] FieldTypes
898.         {
899.             get {return paramTypes;}
900.             set {paramTypes = value;}
901.         }
903.     
904.         public void GetObjectData(SerializationInfo info, StreamingContext context)
905.         {
907.             int numberOfMembers = 0;
909.             if (paramValues != null)
910.                 numberOfMembers = paramValues.Length;
912.             InternalST.Soap(this, "GetObjectData ",methodName," "+numberOfMembers);        
914.             info.FullTypeName = methodName;
915.             if (xmlNameSpace != null)
916.                 info.AssemblyName = xmlNameSpace;
918.             String paramName = null;
919.             if (paramValues != null)
920.             {
921.                 for (int i=0; i<paramValues.Length; i++)
922.                 {
923.                     InternalST.Soap(this, "GetObjectData AddValue ",paramNames[i]," ",paramValues[i]);
925.                     if ((paramNames != null) && (paramNames[i] == null))
926.                         paramName = "param"+i;
927.                     else
928.                         paramName = paramNames[i];
929.                     info.AddValue(paramName, paramValues[i], typeof(Object));
930.                 }
931.             }
933.         }
935.         internal void SetObjectData(SerializationInfo info, StreamingContext context)
936.         {
937.             InternalST.Soap(this, "SetObjectData ");                    
938.             ArrayList paramValuesList = new ArrayList(20); 
939.             methodName = (string)info.GetString("__methodName");
940.             keyToNamespaceTable = (Hashtable)info.GetValue("__keyToNamespaceTable", typeof(Hashtable));
941.             ArrayList paramNamesList = (ArrayList)info.GetValue("__paramNameList", typeof(ArrayList));
942.             xmlNameSpace = (String)info.GetString("__xmlNameSpace");
944.             for (int i=0; i<paramNamesList.Count; i++)
945.                 paramValuesList.Add(info.GetValue((string)paramNamesList[i], Converter.typeofObject));
947.             paramNames = new String[paramNamesList.Count];
948.             paramValues = new Object[paramValuesList.Count];
950.             for (int i=0; i<paramNamesList.Count; i++)
951.             {
952.                 paramNames[i] = (String)paramNamesList[i];
953.                 paramValues[i] = (Object)paramValuesList[i];
954.                 InternalST.Soap(this, "SetObjectData param ",i," ",paramNames[i]," paramValue ",paramValues[i]);                                                                    
955.             }
956.         }
957.     }
959.     internal sealed class SoapAttributeInfo
960.     {
961.         internal SoapAttributeType m_attributeType;
962.         internal String m_nameSpace;
963.         internal String m_elementName;
964.         internal String m_typeName;
965.         internal String m_typeNamespace;
967.         internal String AttributeNameSpace
968.         {
969.             get {return m_nameSpace;}
970.         }
972.         internal String AttributeElementName
973.         {
974.             get {return m_elementName;}
975.         }
977.         internal String AttributeTypeName
978.         {
979.             get {return m_typeName;}
980.         }
982.         internal String AttributeTypeNamespace
983.         {
984.             get {return m_typeNamespace;}
985.         }
987.         internal bool IsEmbedded()
988.         {
989.             if ((m_attributeType & SoapAttributeType.Embedded) > 0)
990.                 return true;
991.             else
992.                 return false;
993.         }
995.         internal bool IsXmlElement()
996.         {
997.             if ((m_attributeType & SoapAttributeType.XmlElement) > 0)
998.                 return true;
999.             else
1000.                 return false;
1001.         }
1003.         internal bool IsXmlAttribute()
1004.         {
1005.             if ((m_attributeType & SoapAttributeType.XmlAttribute) > 0)
1006.                 return true;
1007.             else
1008.                 return false;
1009.         }
1011.         internal bool IsXmlType()
1012.         {
1013.             if ((m_attributeType & SoapAttributeType.XmlType) > 0)
1014.                 return true;
1015.             else
1016.                 return false;
1017.         }
1018.         
1019.         [Conditional("SER_LOGGING")]
1020.         internal void Dump(String id)
1021.         {
1022.             InternalST.Soap("Dump SoapAttributeInfo ", id);
1023.             if (IsXmlType())
1024.                 InternalST.Soap("   SchemaType");
1025.             if (IsEmbedded())
1026.                 InternalST.Soap("   Embedded");
1027.             if (IsXmlElement())
1028.                 InternalST.Soap("   XmlElement");
1029.             if (IsXmlAttribute())
1030.                 InternalST.Soap("   XmlAttribute");            
1031.             Util.NVTrace("_nameSpace", m_nameSpace);
1032.             Util.NVTrace("_elementName", m_elementName);
1033.             Util.NVTrace("_type", m_typeName);            
1034.         }
1035.     }
1037.     internal class ObjectIdentityComparer : IComparer
1038.     {
1039.         //READTHIS READTHIS
1040.        //This cannot be used for sorting objects, but it's useful in a hashtable
1041.         //where we just care about equality.
1042.         public int Compare(Object x, Object y) {
1043.         
1044.             if (x==y) {
1045.                 return 0;
1046.             }
1048.             return 1;
1049.         }
1050.     }
1052.     internal class ObjectHashCodeProvider : IHashCodeProvider
1053.     {
1054.         public int GetHashCode(Object obj)
1055.         {
1056.             return obj.GetHashCode();
1058.         }
1059.     }
1061.         
1062.     
1064.     internal sealed class NameInfo
1065.     {
1066.         internal InternalNameSpaceE NInameSpaceEnum = InternalNameSpaceE.None;
1067.         internal String NIname; // Name from SerObjectInfo.GetType
1068.         //internal String elementName; // Name from SerObjectInfo.GetElementName, will be the same as GetType except for interopTypes
1069.         //internal String interopType; 
1070.         internal long NIobjectId;
1071.         internal long NIassemId;
1072.         internal InternalPrimitiveTypeE NIprimitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
1073.         internal Type NItype;
1074.         internal bool NIisSealed;
1075.         internal bool NIisMustUnderstand;
1076.         internal String NInamespace;
1077.         internal String NIheaderPrefix;
1078.         internal String NIitemName;
1079.         internal bool NIisArray;
1080.         internal bool NIisArrayItem;
1081.         internal bool NIisTopLevelObject;
1082.         internal bool NIisNestedObject;
1083.         internal bool NItransmitTypeOnObject;
1084.         internal bool NItransmitTypeOnMember;
1085.         internal bool NIisParentTypeOnObject;
1086.         internal bool NIisHeader;
1087.         internal bool NIisRemoteRecord;
1088.         internal int NIid;
1089.         internal SoapAttributeInfo NIattributeInfo;
1091.         private static int count;
1093.         internal NameInfo()
1094.         {
1095.             Counter();
1096.         }
1098.         [Conditional("SER_LOGGING")]
1099.         private void Counter()
1100.         {
1101.             lock(typeof(NameInfo))
1102.             {
1103.                 NIid = count++;
1104.             }
1105.         }
1107.         internal void Init()
1108.         {
1109.             NInameSpaceEnum = InternalNameSpaceE.None;
1110.             NIname = null;
1111.             NIobjectId = 0;
1112.             NIassemId = 0;
1113.             NIprimitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
1114.             NItype = null;
1115.             NIisSealed = false;
1116.             NItransmitTypeOnObject = false;
1117.             NItransmitTypeOnMember = false;
1118.             NIisParentTypeOnObject = false;
1119.             NIisMustUnderstand = false;
1120.             NInamespace = null;
1121.             NIheaderPrefix = null;
1122.             NIitemName = null;
1123.             NIisArray = false;
1124.             NIisArrayItem = false;
1125.             NIisTopLevelObject = false;
1126.             NIisNestedObject = false;
1127.             NIisHeader = false;
1128.             NIisRemoteRecord = false;
1129.             NIattributeInfo = null;
1130.         }
1132.         [Conditional("SER_LOGGING")]
1133.         internal void Dump(String value)
1134.         {
1135.             InternalST.Soap("Dump NameInfo ",NIid," ",value);
1136.             Util.NVTrace("nameSpaceEnum", ((Enum)NInameSpaceEnum).ToString());
1137.             Util.NVTrace("name", NIname);
1138.             Util.NVTrace("objectId", NIobjectId);
1139.             Util.NVTrace("assemId", NIassemId);
1140.             Util.NVTrace("primitiveTypeEnum", ((Enum)NIprimitiveTypeEnum).ToString());
1141.             Util.NVTrace("type", NItype);
1142.             Util.NVTrace("isSealed", NIisSealed);            
1143.             Util.NVTrace("transmitTypeOnObject", NItransmitTypeOnObject);
1144.             Util.NVTrace("transmitTypeOnMember", NItransmitTypeOnMember);
1145.             Util.NVTrace("isParentTypeOnObject", NIisParentTypeOnObject);                
1146.             Util.NVTrace("isMustUnderstand", NIisMustUnderstand);
1147.             Util.NVTrace("namespace", NInamespace);
1148.             Util.NVTrace("headerPrefix", NIheaderPrefix);
1149.             Util.NVTrace("itemName", NIitemName);                
1150.             Util.NVTrace("isArray", NIisArray);
1151.             Util.NVTrace("isArrayItem", NIisArrayItem);
1152.             Util.NVTrace("isTopLevelObject", NIisTopLevelObject);
1153.             Util.NVTrace("isNestedObject", NIisNestedObject);
1154.             Util.NVTrace("isHeader", NIisHeader);
1155.             Util.NVTrace("isRemoteRecord", NIisRemoteRecord);
1156.             if (NIattributeInfo != null)
1157.                 NIattributeInfo.Dump(NIname);
1158.         }
1160.     }
1162.     internal sealed class PrimitiveArray
1163.     {
1164.         InternalPrimitiveTypeE code;
1165.         Boolean[] booleanA = null;
1166.         Char[] charA = null;
1167.         Double[] doubleA = null;
1168.         Int16[] int16A = null;
1169.         Int32[] int32A = null;
1170.         Int64[] int64A = null;
1171.         SByte[] sbyteA = null;
1172.         Single[] singleA = null;
1173.         UInt16[] uint16A = null;
1174.         UInt32[] uint32A = null;
1175.         UInt64[] uint64A = null;
1178.         internal PrimitiveArray(InternalPrimitiveTypeE code, Array array)
1179.         {
1180.             Init(code, array);
1181.         }
1183.         internal void Init(InternalPrimitiveTypeE code, Array array)
1184.         {
1185.             this.code = code;
1186.             switch(code)
1187.             {
1188.                 case InternalPrimitiveTypeE.Boolean:
1189.                     booleanA = (Boolean[])array;
1190.                     break;
1191.                 case InternalPrimitiveTypeE.Char:
1192.                     charA = (Char[])array;
1193.                     break;                    
1194.                 case InternalPrimitiveTypeE.Double:
1195.                     doubleA = (Double[])array;
1196.                     break;                    
1197.                 case InternalPrimitiveTypeE.Int16:
1198.                     int16A = (Int16[])array;
1199.                     break;                    
1200.                 case InternalPrimitiveTypeE.Int32:
1201.                     int32A = (Int32[])array;
1202.                     break;                    
1203.                 case InternalPrimitiveTypeE.Int64:
1204.                     int64A = (Int64[])array;
1205.                     break;                    
1206.                 case InternalPrimitiveTypeE.SByte:
1207.                     sbyteA = (SByte[])array;
1208.                     break;                    
1209.                 case InternalPrimitiveTypeE.Single:
1210.                     singleA = (Single[])array;
1211.                     break;                    
1212.                 case InternalPrimitiveTypeE.UInt16:
1213.                     uint16A = (UInt16[])array;
1214.                     break;                    
1215.                 case InternalPrimitiveTypeE.UInt32:
1216.                     uint32A = (UInt32[])array;
1217.                     break;                    
1218.                 case InternalPrimitiveTypeE.UInt64:
1219.                     uint64A = (UInt64[])array;
1220.                     break;
1221.             }
1222.         }
1224.         internal String GetValue(int index)
1225.         {
1226.             String value = null;
1227.             switch(code)
1228.             {
1229.                 case InternalPrimitiveTypeE.Boolean:
1230.                     value =  (booleanA[index]).ToString();
1231.                     break;
1232.                 case InternalPrimitiveTypeE.Char:
1233.                     if (charA[index] == Char.MinValue)
1234.                         value = "_0x00_";
1235.                     else
1236.                         value =  Char.ToString(charA[index]);
1237.                     break;                    
1238.                 case InternalPrimitiveTypeE.Double:
1239.                     if (Double.IsPositiveInfinity(doubleA[index]))
1240.                         value = "INF";
1241.                     else if (Double.IsNegativeInfinity(doubleA[index]))
1242.                         value = "-INF";
1243.                     else
1244.                         value =  (doubleA[index]).ToString("R", CultureInfo.InvariantCulture);
1245.                     break;                    
1246.                 case InternalPrimitiveTypeE.Int16:
1247.                     value =  (int16A[index]).ToString(CultureInfo.InvariantCulture);
1248.                     break;                    
1249.                 case InternalPrimitiveTypeE.Int32:
1250.                     value =  (int32A[index]).ToString(CultureInfo.InvariantCulture);
1251.                     break;                    
1252.                 case InternalPrimitiveTypeE.Int64:
1253.                     value =  (int64A[index]).ToString(CultureInfo.InvariantCulture);
1254.                     break;                    
1255.                 case InternalPrimitiveTypeE.SByte:
1256.                     value =  (sbyteA[index]).ToString(CultureInfo.InvariantCulture);
1257.                     break;                    
1258.                 case InternalPrimitiveTypeE.Single:
1259.                     if (Single.IsPositiveInfinity(singleA[index]))
1260.                         value = "INF";
1261.                     else if (Single.IsNegativeInfinity(singleA[index]))
1262.                         value = "-INF";
1263.                     else
1264.                         value =  (singleA[index]).ToString("R", CultureInfo.InvariantCulture);
1265.                     break;
1266.                 case InternalPrimitiveTypeE.UInt16:
1267.                     value =  (uint16A[index]).ToString(CultureInfo.InvariantCulture);
1268.                     break;
1269.                 case InternalPrimitiveTypeE.UInt32:
1270.                     value =  (uint32A[index]).ToString(CultureInfo.InvariantCulture);
1271.                     break;                    
1272.                 case InternalPrimitiveTypeE.UInt64:
1273.                     value =  (uint64A[index]).ToString(CultureInfo.InvariantCulture);
1274.                     break;                    
1275.             }
1276.             return value;
1277.         }
1279.         internal void SetValue(String value, int index)
1280.         {
1281.             InternalST.Soap("PrimitiveArray value ", value," index ", index, " code ",((Enum)code).ToString());
1282.             switch(code)
1283.             {
1284.                 case InternalPrimitiveTypeE.Boolean:
1285.                     booleanA[index] = Boolean.Parse(value);
1286.                     break;
1287.                 case InternalPrimitiveTypeE.Char:
1288.                     if ((value[0] == '_') && (value.Equals("_0x00_")))
1289.                         charA[index] = Char.MinValue;
1290.                     else
1291.                         charA[index] = Char.Parse(value);
1292.                     break;                    
1293.                 case InternalPrimitiveTypeE.Double:
1294.                     if (value == "INF")
1295.                         doubleA[index] =  Double.PositiveInfinity;
1296.                     else if (value == "-INF")
1297.                         doubleA[index] =  Double.NegativeInfinity;
1298.                     else
1299.                         doubleA[index] = Double.Parse(value, CultureInfo.InvariantCulture);
1300.                     break;                    
1301.                 case InternalPrimitiveTypeE.Int16:
1302.                     int16A[index] = Int16.Parse(value, CultureInfo.InvariantCulture);                                                            
1303.                     break;                    
1304.                 case InternalPrimitiveTypeE.Int32:
1305.                     int32A[index] = Int32.Parse(value, CultureInfo.InvariantCulture);                                                                                
1306.                     break;                    
1307.                 case InternalPrimitiveTypeE.Int64:
1308.                     int64A[index] = Int64.Parse(value, CultureInfo.InvariantCulture);                                                                                                    
1309.                     break;                    
1310.                 case InternalPrimitiveTypeE.SByte:
1311.                     sbyteA[index] = SByte.Parse(value, CultureInfo.InvariantCulture);
1312.                     break;                    
1313.                 case InternalPrimitiveTypeE.Single:
1314.                     if (value == "INF")
1315.                         singleA[index] =  Single.PositiveInfinity;
1316.                     else if (value == "-INF")
1317.                         singleA[index] =  Single.NegativeInfinity;
1318.                     else
1319.                         singleA[index] = Single.Parse(value, CultureInfo.InvariantCulture);
1320.                     break;
1321.                 case InternalPrimitiveTypeE.UInt16:
1322.                     uint16A[index] = UInt16.Parse(value, CultureInfo.InvariantCulture);
1323.                     break;
1324.                 case InternalPrimitiveTypeE.UInt32:
1325.                     uint32A[index] = UInt32.Parse(value, CultureInfo.InvariantCulture);                    
1326.                     break;                    
1327.                 case InternalPrimitiveTypeE.UInt64:
1328.                     uint64A[index] = UInt64.Parse(value, CultureInfo.InvariantCulture);                    
1329.                     break;                    
1330.             }
1331.         }
1332.     }
1333. }