bool MemberHasValue(XmlTypeMapMember member, object ob, bool isValueList)
{
if (isValueList)
{
return(member.GlobalIndex < ((object[])ob).Length);
}
else if (member.DefaultValue != System.DBNull.Value)
{
object val = GetMemberValue(member, ob, isValueList);
if (val == null && member.DefaultValue == null)
{
return(false);
}
if (val != null && val.GetType().IsEnum)
{
if (val.Equals(member.DefaultValue))
{
return(false);
}
Type t = Enum.GetUnderlyingType(val.GetType());
val = Convert.ChangeType(val, t);
}
if (val != null && val.Equals(member.DefaultValue))
{
return(false);
}
}
else if (member.IsOptionalValueType)
{
return(member.GetValueSpecified(ob));
}
return(true);
}
void ReadAttributeMembers(ClassMap map, object ob, bool isValueList)
{
XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
int anyAttributeIndex = 0;
object anyAttributeArray = null;
while (Reader.MoveToNextAttribute())
{
XmlTypeMapMemberAttribute member = map.GetAttribute(Reader.LocalName, Reader.NamespaceURI);
if (member != null)
{
SetMemberValue(member, ob, GetValueFromXmlString(Reader.Value, member.TypeData, member.MappedType), isValueList);
}
else if (IsXmlnsAttribute(Reader.Name))
{
// If the map has NamespaceDeclarations,
// then store this xmlns to the given member.
// If the instance doesn't exist, then create.
if (map.NamespaceDeclarations != null)
{
XmlSerializerNamespaces nss = this.GetMemberValue(map.NamespaceDeclarations, ob, isValueList) as XmlSerializerNamespaces;
if (nss == null)
{
nss = new XmlSerializerNamespaces();
SetMemberValue(map.NamespaceDeclarations, ob, nss, isValueList);
}
if (Reader.Prefix == "xmlns")
{
nss.Add(Reader.LocalName, Reader.Value);
}
else
{
nss.Add("", Reader.Value);
}
}
}
#if !MOONLIGHT
else if (anyAttrMember != null)
{
XmlAttribute attr = (XmlAttribute)Document.ReadNode(Reader);
ParseWsdlArrayType(attr);
AddListValue(anyAttrMember.TypeData, ref anyAttributeArray, anyAttributeIndex++, attr, true);
}
else
{
ProcessUnknownAttribute(ob);
}
#endif
}
#if !MOONLIGHT
if (anyAttrMember != null)
{
anyAttributeArray = ShrinkArray((Array)anyAttributeArray, anyAttributeIndex, anyAttrMember.TypeData.Type.GetElementType(), true);
SetMemberValue(anyAttrMember, ob, anyAttributeArray, isValueList);
}
#endif
Reader.MoveToElement();
}
public XmlTypeMapElementInfo (XmlTypeMapMember member, TypeData type)
{
_member = member;
_type = type;
if (type.IsValueType && type.IsNullable)
_isNullable = true;
}
private void WriteAttributeMembers(ClassMap map, object ob, bool isValueList)
{
XmlTypeMapMember defaultAnyAttributeMember = map.DefaultAnyAttributeMember;
if (defaultAnyAttributeMember != null && this.MemberHasValue(defaultAnyAttributeMember, ob, isValueList))
{
ICollection collection = (ICollection)this.GetMemberValue(defaultAnyAttributeMember, ob, isValueList);
if (collection != null)
{
foreach (object obj in collection)
{
XmlAttribute xmlAttribute = (XmlAttribute)obj;
if (xmlAttribute.NamespaceURI != "http://www.w3.org/2000/xmlns/")
{
base.WriteXmlAttribute(xmlAttribute, ob);
}
}
}
}
ICollection attributeMembers = map.AttributeMembers;
if (attributeMembers != null)
{
foreach (object obj2 in attributeMembers)
{
XmlTypeMapMemberAttribute xmlTypeMapMemberAttribute = (XmlTypeMapMemberAttribute)obj2;
if (this.MemberHasValue(xmlTypeMapMemberAttribute, ob, isValueList))
{
base.WriteAttribute(xmlTypeMapMemberAttribute.AttributeName, xmlTypeMapMemberAttribute.Namespace, this.GetStringValue(xmlTypeMapMemberAttribute.MappedType, xmlTypeMapMemberAttribute.TypeData, this.GetMemberValue(xmlTypeMapMemberAttribute, ob, isValueList)));
}
}
}
}
private bool MemberHasValue(XmlTypeMapMember member, object ob, bool isValueList)
{
if (isValueList)
{
return(member.GlobalIndex < ((object[])ob).Length);
}
if (member.DefaultValue != DBNull.Value)
{
object obj = this.GetMemberValue(member, ob, isValueList);
if (obj == null && member.DefaultValue == null)
{
return(false);
}
if (obj != null && obj.GetType().IsEnum)
{
if (obj.Equals(member.DefaultValue))
{
return(false);
}
Type underlyingType = Enum.GetUnderlyingType(obj.GetType());
obj = Convert.ChangeType(obj, underlyingType);
}
if (obj != null && obj.Equals(member.DefaultValue))
{
return(false);
}
}
else if (member.IsOptionalValueType)
{
return(member.GetValueSpecified(ob));
}
return(true);
}
void WriteAttributeMembers(ClassMap map, object ob, bool isValueList)
{
// Write attributes
XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
if (anyAttrMember != null && MemberHasValue(anyAttrMember, ob, isValueList))
{
ICollection extraAtts = (ICollection)GetMemberValue(anyAttrMember, ob, isValueList);
if (extraAtts != null)
{
foreach (XmlAttribute attr in extraAtts)
{
if (attr.NamespaceURI != xmlNamespace)
{
WriteXmlAttribute(attr, ob);
}
}
}
}
ICollection attributes = map.AttributeMembers;
if (attributes != null)
{
foreach (XmlTypeMapMemberAttribute attr in attributes)
{
if (MemberHasValue(attr, ob, isValueList))
{
WriteAttribute(attr.AttributeName, attr.Namespace, GetStringValue(attr.MappedType, attr.TypeData, GetMemberValue(attr, ob, isValueList)));
}
}
}
}
public XmlTypeMapElementInfo FindElement(object ob, object memberValue)
{
if (this._elementInfo.Count == 1)
{
return((XmlTypeMapElementInfo)this._elementInfo[0]);
}
if (this._choiceMember != null)
{
object value = XmlTypeMapMember.GetValue(ob, this._choiceMember);
foreach (object obj in this._elementInfo)
{
XmlTypeMapElementInfo xmlTypeMapElementInfo = (XmlTypeMapElementInfo)obj;
if (xmlTypeMapElementInfo.ChoiceValue != null && xmlTypeMapElementInfo.ChoiceValue.Equals(value))
{
return(xmlTypeMapElementInfo);
}
}
}
else
{
if (memberValue == null)
{
return((XmlTypeMapElementInfo)this._elementInfo[0]);
}
foreach (object obj2 in this._elementInfo)
{
XmlTypeMapElementInfo xmlTypeMapElementInfo2 = (XmlTypeMapElementInfo)obj2;
if (xmlTypeMapElementInfo2.TypeData.Type.IsInstanceOfType(memberValue))
{
return(xmlTypeMapElementInfo2);
}
}
}
return(null);
}
protected virtual object ReadMessage(XmlMembersMapping typeMap)
{
object[] array = new object[typeMap.Count];
if (typeMap.HasWrapperElement)
{
ArrayList allMembers = ((ClassMap)typeMap.ObjectMap).AllMembers;
for (int i = 0; i < allMembers.Count; i++)
{
XmlTypeMapMember xmlTypeMapMember = (XmlTypeMapMember)allMembers[i];
if (!xmlTypeMapMember.IsReturnValue && xmlTypeMapMember.TypeData.IsValueType)
{
this.SetMemberValueFromAttr(xmlTypeMapMember, array, this.CreateInstance(xmlTypeMapMember.TypeData.Type), true);
}
}
if (this._format == SerializationFormat.Encoded)
{
while (base.Reader.NodeType == XmlNodeType.Element)
{
string attribute = base.Reader.GetAttribute("root", "http://schemas.xmlsoap.org/soap/encoding/");
if (attribute == null || XmlConvert.ToBoolean(attribute))
{
break;
}
base.ReadReferencedElement();
base.Reader.MoveToContent();
}
}
while (base.Reader.NodeType != XmlNodeType.EndElement && base.Reader.ReadState == ReadState.Interactive)
{
if (base.Reader.IsStartElement(typeMap.ElementName, typeMap.Namespace) || this._format == SerializationFormat.Encoded)
{
this.ReadAttributeMembers((ClassMap)typeMap.ObjectMap, array, true);
if (!base.Reader.IsEmptyElement)
{
base.Reader.ReadStartElement();
this.ReadMembers((ClassMap)typeMap.ObjectMap, array, true, false);
base.ReadEndElement();
break;
}
base.Reader.Skip();
base.Reader.MoveToContent();
}
else
{
base.UnknownNode(null);
base.Reader.MoveToContent();
}
}
}
else
{
this.ReadMembers((ClassMap)typeMap.ObjectMap, array, true, this._format == SerializationFormat.Encoded);
}
if (this._format == SerializationFormat.Encoded)
{
base.ReadReferencedElements();
}
return(array);
}
internal XmlMemberMapping(string memberName, string defaultNamespace, XmlTypeMapMember mapMem, bool encodedFormat)
{
this._mapMember = mapMem;
this._memberName = memberName;
if (mapMem is XmlTypeMapMemberAnyElement)
{
XmlTypeMapMemberAnyElement xmlTypeMapMemberAnyElement = (XmlTypeMapMemberAnyElement)mapMem;
XmlTypeMapElementInfo xmlTypeMapElementInfo = (XmlTypeMapElementInfo)xmlTypeMapMemberAnyElement.ElementInfo[xmlTypeMapMemberAnyElement.ElementInfo.Count - 1];
this._elementName = xmlTypeMapElementInfo.ElementName;
this._namespace = xmlTypeMapElementInfo.Namespace;
if (xmlTypeMapElementInfo.MappedType != null)
{
this._typeNamespace = xmlTypeMapElementInfo.MappedType.Namespace;
}
else
{
this._typeNamespace = string.Empty;
}
}
else if (mapMem is XmlTypeMapMemberElement)
{
XmlTypeMapElementInfo xmlTypeMapElementInfo2 = (XmlTypeMapElementInfo)((XmlTypeMapMemberElement)mapMem).ElementInfo[0];
this._elementName = xmlTypeMapElementInfo2.ElementName;
if (encodedFormat)
{
this._namespace = defaultNamespace;
if (xmlTypeMapElementInfo2.MappedType != null)
{
this._typeNamespace = string.Empty;
}
else
{
this._typeNamespace = xmlTypeMapElementInfo2.DataTypeNamespace;
}
}
else
{
this._namespace = xmlTypeMapElementInfo2.Namespace;
if (xmlTypeMapElementInfo2.MappedType != null)
{
this._typeNamespace = xmlTypeMapElementInfo2.MappedType.Namespace;
}
else
{
this._typeNamespace = string.Empty;
}
this._form = xmlTypeMapElementInfo2.Form;
}
}
else
{
this._elementName = this._memberName;
this._namespace = string.Empty;
}
if (this._form == XmlSchemaForm.None)
{
this._form = XmlSchemaForm.Qualified;
}
}
private object GetMemberValue(XmlTypeMapMember member, object ob, bool isValueList)
{
if (isValueList)
{
return(((object[])ob)[member.GlobalIndex]);
}
return(member.GetValue(ob));
}
private bool IsReadOnly(XmlTypeMapMember member, TypeData memType, object ob, bool isValueList)
{
if (isValueList)
{
return(!memType.HasPublicConstructor);
}
return(member.IsReadOnly(ob.GetType()) || !memType.HasPublicConstructor);
}
private void SetMemberValueFromAttr(XmlTypeMapMember member, object ob, object value, bool isValueList)
{
if (member.TypeData.Type.IsEnum)
{
value = Enum.ToObject(member.TypeData.Type, value);
}
this.SetMemberValue(member, ob, value, isValueList);
}
public XmlTypeMapElementInfo(XmlTypeMapMember member, TypeData type)
{
_member = member;
_type = type;
if (type.IsValueType && type.IsNullable)
{
_isNullable = true;
}
}
bool IsReadOnly(XmlTypeMapMember member, object ob, bool isValueList)
{
if (isValueList)
{
return(false);
}
else
{
return(member.IsReadOnly(ob.GetType()));
}
}
object GetMemberValue(XmlTypeMapMember member, object ob, bool isValueList)
{
if (isValueList)
{
return(((object[])ob)[member.Index]);
}
else
{
return(member.GetValue(ob));
}
}
void SetMemberValueFromAttr(XmlTypeMapMember member, object ob, object value, bool isValueList)
{
// Enumeration values specified in custom attributes are stored as integer
// values if the custom attribute property is of type object. So, it is
// necessary to convert to the enum type before asigning the value to the field.
if (member.TypeData.Type.IsEnum)
{
value = Enum.ToObject(member.TypeData.Type, value);
}
SetMemberValue(member, ob, value, isValueList);
}
private void ReadAttributeMembers(ClassMap map, object ob, bool isValueList)
{
XmlTypeMapMember defaultAnyAttributeMember = map.DefaultAnyAttributeMember;
int length = 0;
object obj = null;
while (base.Reader.MoveToNextAttribute())
{
XmlTypeMapMemberAttribute attribute = map.GetAttribute(base.Reader.LocalName, base.Reader.NamespaceURI);
if (attribute != null)
{
this.SetMemberValue(attribute, ob, this.GetValueFromXmlString(base.Reader.Value, attribute.TypeData, attribute.MappedType), isValueList);
}
else if (base.IsXmlnsAttribute(base.Reader.Name))
{
if (map.NamespaceDeclarations != null)
{
XmlSerializerNamespaces xmlSerializerNamespaces = this.GetMemberValue(map.NamespaceDeclarations, ob, isValueList) as XmlSerializerNamespaces;
if (xmlSerializerNamespaces == null)
{
xmlSerializerNamespaces = new XmlSerializerNamespaces();
this.SetMemberValue(map.NamespaceDeclarations, ob, xmlSerializerNamespaces, isValueList);
}
if (base.Reader.Prefix == "xmlns")
{
xmlSerializerNamespaces.Add(base.Reader.LocalName, base.Reader.Value);
}
else
{
xmlSerializerNamespaces.Add(string.Empty, base.Reader.Value);
}
}
}
else if (defaultAnyAttributeMember != null)
{
XmlAttribute xmlAttribute = (XmlAttribute)base.Document.ReadNode(base.Reader);
base.ParseWsdlArrayType(xmlAttribute);
this.AddListValue(defaultAnyAttributeMember.TypeData, ref obj, length++, xmlAttribute, true);
}
else
{
this.ProcessUnknownAttribute(ob);
}
}
if (defaultAnyAttributeMember != null)
{
obj = base.ShrinkArray((Array)obj, length, defaultAnyAttributeMember.TypeData.Type.GetElementType(), true);
this.SetMemberValue(defaultAnyAttributeMember, ob, obj, isValueList);
}
base.Reader.MoveToElement();
}
CodeMemberField CreateFieldMember(XmlTypeMapMember member)
{
CodeMemberField codeField = new CodeMemberField(GetDomType(member.TypeData), member.Name);
codeField.Attributes = MemberAttributes.Public;
AddComments(codeField, member.Documentation);
if (member.DefaultValue != System.DBNull.Value)
{
GenerateDefaultAttribute(codeField, member.TypeData, member.DefaultValue);
}
return(codeField);
}
public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate)
{
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n = 0; n < members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember(members[n], ns);
mapping[n] = new XmlMemberMapping(members[n].MemberName, ns, mapMem, true);
}
XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Encoded;
mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, includedTypes);
return(mps);
}
void SetMemberValue(XmlTypeMapMember member, object ob, object value, bool isValueList)
{
if (isValueList)
{
((object[])ob)[member.GlobalIndex] = value;
}
else
{
member.SetValue(ob, value);
}
if (member.IsOptionalValueType)
{
member.SetValueSpecified(ob, true);
}
}
bool DefinedInBaseMap(XmlTypeMapping map, XmlTypeMapMember member)
{
if (((ClassMap)map.ObjectMap).FindMember(member.Name) != null)
{
return(true);
}
else if (map.BaseMap != null)
{
return(DefinedInBaseMap(map.BaseMap, member));
}
else
{
return(false);
}
}
internal void FixupMembers(ClassMap map, object obfixup, bool isValueList)
{
XmlSerializationReader.Fixup fixup = (XmlSerializationReader.Fixup)obfixup;
ICollection elementMembers = map.ElementMembers;
string[] ids = fixup.Ids;
foreach (object obj in elementMembers)
{
XmlTypeMapMember xmlTypeMapMember = (XmlTypeMapMember)obj;
if (ids[xmlTypeMapMember.Index] != null)
{
this.SetMemberValue(xmlTypeMapMember, fixup.Source, base.GetTarget(ids[xmlTypeMapMember.Index]), isValueList);
}
}
}
public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access)
{
elementName = XmlConvert.EncodeLocalName(elementName);
XmlMemberMapping[] array = new XmlMemberMapping[members.Length];
for (int i = 0; i < members.Length; i++)
{
XmlTypeMapMember mapMem = this.CreateMapMember(members[i], ns);
array[i] = new XmlMemberMapping(XmlConvert.EncodeLocalName(members[i].MemberName), ns, mapMem, true);
}
XmlMembersMapping xmlMembersMapping = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, array);
xmlMembersMapping.RelatedMaps = this.relatedMaps;
xmlMembersMapping.Format = SerializationFormat.Encoded;
Type[] array2 = (this.includedTypes == null) ? null : ((Type[])this.includedTypes.ToArray(typeof(Type)));
xmlMembersMapping.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, array2);
return(xmlMembersMapping);
}
public XmlTypeMapElementInfo FindElement(object ob, int index, object memberValue)
{
if (_itemInfo.Count == 1)
{
return((XmlTypeMapElementInfo)_itemInfo[0]);
}
else if (_choiceMember != null && index != -1)
{
Array values = (Array)XmlTypeMapMember.GetValue(ob, _choiceMember);
if (values == null || index >= values.Length)
{
throw new InvalidOperationException("Invalid or missing choice enum value in member '" + _choiceMember + "'.");
}
object val = values.GetValue(index);
foreach (XmlTypeMapElementInfo elem in _itemInfo)
{
if (elem.ChoiceValue != null && elem.ChoiceValue.Equals(val))
{
return(elem);
}
}
}
else
{
if (memberValue == null)
{
return(null);
}
Type type = memberValue.GetType();
XmlTypeMapElementInfo bestMatch = null;
foreach (XmlTypeMapElementInfo elem in _itemInfo)
{
if (elem.TypeData.Type == type)
{
return(elem);
}
if (elem.TypeData.Type.IsAssignableFrom(type) &&
(bestMatch == null || elem.TypeData.Type.IsAssignableFrom(bestMatch.TypeData.Type)))
{
bestMatch = elem;
}
}
return(bestMatch);
}
return(null);
}
XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access)
{
elementName = XmlConvert.EncodeLocalName(elementName);
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n = 0; n < members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember(members[n], ns);
mapping[n] = new XmlMemberMapping(XmlConvert.EncodeLocalName(members[n].MemberName), ns, mapMem, true);
}
XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Encoded;
Type[] extraTypes = includedTypes != null ? (Type[])includedTypes.ToArray(typeof(Type)) : null;
mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, extraTypes);
return(mps);
}
private void SetListMembersDefaults(ClassMap map, object ob, bool isValueList)
{
if (map.ListMembers != null)
{
ArrayList listMembers = map.ListMembers;
for (int i = 0; i < listMembers.Count; i++)
{
XmlTypeMapMember xmlTypeMapMember = (XmlTypeMapMember)listMembers[i];
if (!this.IsReadOnly(xmlTypeMapMember, xmlTypeMapMember.TypeData, ob, isValueList))
{
if (this.GetMemberValue(xmlTypeMapMember, ob, isValueList) == null)
{
this.SetMemberValue(xmlTypeMapMember, ob, this.InitializeList(xmlTypeMapMember.TypeData), isValueList);
}
}
}
}
}
void SetListMembersDefaults(ClassMap map, object ob, bool isValueList)
{
if (map.ListMembers != null)
{
ArrayList members = map.ListMembers;
for (int n = 0; n < members.Count; n++)
{
XmlTypeMapMember mem = (XmlTypeMapMember)members[n];
if (IsReadOnly(mem, mem.TypeData, ob, isValueList))
{
continue;
}
if (GetMemberValue(mem, ob, isValueList) == null)
{
SetMemberValue(mem, ob, InitializeList(mem.TypeData), isValueList);
}
}
}
}
public XmlTypeMapElementInfo FindElement(object ob, int index, object memberValue)
{
if (this._itemInfo.Count == 1)
{
return((XmlTypeMapElementInfo)this._itemInfo[0]);
}
if (this._choiceMember != null && index != -1)
{
Array array = (Array)XmlTypeMapMember.GetValue(ob, this._choiceMember);
if (array == null || index >= array.Length)
{
throw new InvalidOperationException("Invalid or missing choice enum value in member '" + this._choiceMember + "'.");
}
object value = array.GetValue(index);
foreach (object obj in this._itemInfo)
{
XmlTypeMapElementInfo xmlTypeMapElementInfo = (XmlTypeMapElementInfo)obj;
if (xmlTypeMapElementInfo.ChoiceValue != null && xmlTypeMapElementInfo.ChoiceValue.Equals(value))
{
return(xmlTypeMapElementInfo);
}
}
}
else
{
if (memberValue == null)
{
return(null);
}
Type type = memberValue.GetType();
foreach (object obj2 in this._itemInfo)
{
XmlTypeMapElementInfo xmlTypeMapElementInfo2 = (XmlTypeMapElementInfo)obj2;
if (xmlTypeMapElementInfo2.TypeData.Type == type)
{
return(xmlTypeMapElementInfo2);
}
}
}
return(null);
}
internal XmlMemberMapping (string memberName, string defaultNamespace, XmlTypeMapMember mapMem, bool encodedFormat)
{
_mapMember = mapMem;
_memberName = memberName;
if (mapMem is XmlTypeMapMemberAnyElement)
{
XmlTypeMapMemberAnyElement anyelem = (XmlTypeMapMemberAnyElement) mapMem;
XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) anyelem.ElementInfo[anyelem.ElementInfo.Count-1];
_elementName = info.ElementName;
_namespace = info.Namespace;
if (info.MappedType != null) _typeNamespace = info.MappedType.Namespace;
else _typeNamespace = "";
}
else if (mapMem is XmlTypeMapMemberElement)
{
XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) ((XmlTypeMapMemberElement)mapMem).ElementInfo[0];
_elementName = info.ElementName;
if (encodedFormat)
{
_namespace = defaultNamespace;
if (info.MappedType != null) _typeNamespace = "";
else _typeNamespace = info.DataTypeNamespace;
}
else
{
_namespace = info.Namespace;
if (info.MappedType != null) _typeNamespace = info.MappedType.Namespace;
else _typeNamespace = "";
_form = info.Form;
}
}
else
{
_elementName = _memberName;
_namespace = "";
}
if (_form == XmlSchemaForm.None)
_form = XmlSchemaForm.Qualified;
}
void SetMemberValue(XmlTypeMapMember member, object ob, object value, bool isValueList)
{
var memberType = member.TypeData.Type;
if (value != null && !value.GetType().IsAssignableFrom(memberType))
{
value = XmlSerializationWriterInterpreter.ImplicitConvert(value, memberType);
}
if (isValueList)
{
((object[])ob)[member.GlobalIndex] = value;
}
else
{
member.SetValue(ob, value);
}
if (member.IsOptionalValueType)
{
member.SetValueSpecified(ob, true);
}
}
public XmlMembersMapping ImportMembersMapping(string elementName,
string ns,
XmlReflectionMember [] members,
bool hasWrapperElement)
{
// Reset (); Disabled. See ChangeLog
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n = 0; n < members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember(members[n], ns);
mapping[n] = new XmlMemberMapping(members[n].MemberName, ns, mapMem, false);
}
XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, false, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Literal;
mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, false, true, ns, includedTypes);
if (allowPrivateTypes)
{
mps.Source.CanBeGenerated = false;
}
return(mps);
}
string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
{
if (isValueList) {
if (member.IsOptionalValueType)
return ob + ".Length > " + Math.Max (member.GlobalIndex, member.SpecifiedGlobalIndex) + " && " + GetCast (typeof(bool), ob + "[" + member.SpecifiedGlobalIndex + "]");
else
return ob + ".Length > " + member.GlobalIndex;
}
else if (member.DefaultValue != System.DBNull.Value) {
string mem = ob + ".@" + member.Name;
if (member.DefaultValue == null)
return mem + " != null";
else if (member.TypeData.SchemaType == SchemaTypes.Enum)
return mem + " != " + GetCast (member.TypeData, GetLiteral (member.DefaultValue));
else
return mem + " != " + GetLiteral (member.DefaultValue);
}
else if (member.IsOptionalValueType)
return ob + ".@" + member.Name + "Specified";
return null;
}
string GenerateGetMemberValue (XmlTypeMapMember member, string ob, bool isValueList)
{
if (isValueList) return GetCast (member.TypeData, TypeTranslator.GetTypeData (typeof(object)), ob + "[" + member.GlobalIndex + "]");
else return ob + ".@" + member.Name;
}
public XmlTypeMapElementInfo (XmlTypeMapMember member, TypeData type)
{
_member = member;
_type = type;
}
void SetMemberValue (XmlTypeMapMember member, object ob, object value, bool isValueList)
{
if (isValueList) ((object[])ob)[member.GlobalIndex] = value;
else {
member.SetValue (ob, value);
if (member.IsOptionalValueType)
member.SetValueSpecified (ob, true);
}
}
bool MemberHasReadReplaceHook (Type type, XmlTypeMapMember member)
{
if (_config == null) return false;
return _config.GetHooks (HookType.member, HookDir.Read, HookAction.Replace, type, member.Name).Count > 0;
}
bool GenerateReadMemberHook (Type type, XmlTypeMapMember member)
{
SetHookVar ("$MEMBER", member.Name);
return GenerateHook (HookType.member, HookDir.Read, type, member.Name);
}
void GenerateSetMemberValue (XmlTypeMapMember member, string ob, string value, bool isValueList, bool initializingMember)
{
if (isValueList) {
WriteLine (ob + "[" + member.GlobalIndex + "] = " + value + ";");
if (member.IsOptionalValueType) {
string val = initializingMember ? "false" : "true";
WriteLine (ob + "[" + member.SpecifiedGlobalIndex + "] = " + val + ";");
}
}
else {
WriteLine (ob + ".@" + member.Name + " = " + value + ";");
if (member.IsOptionalValueType) {
string val = initializingMember ? "false" : "true";
WriteLine (ob + "." + member.Name + "Specified = " + val + ";");
}
}
}
void GenerateSetMemberValue (XmlTypeMapMember member, string ob, string value, bool isValueList)
{
if (isValueList) WriteLine (ob + "[" + member.GlobalIndex + "] = " + value + ";");
else {
WriteLine (ob + ".@" + member.Name + " = " + value + ";");
if (member.IsOptionalValueType)
WriteLine (ob + "." + member.Name + "Specified = true;");
}
}
XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form, XmlTypeMapping emap, int order)
{
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);
einfo.ElementName = name;
einfo.Namespace = ns;
einfo.IsNullable = isNillable;
einfo.Form = GetForm (form, ns, true);
if (typeData.IsComplexType)
einfo.MappedType = emap;
einfo.ExplicitOrder = order;
return einfo;
}
bool ImportChoices (XmlQualifiedName typeQName, XmlTypeMapMember member, XmlTypeMapElementInfoList choices, XmlSchemaObjectCollection items)
{
bool multiValue = false;
foreach (XmlSchemaObject titem in items)
{
XmlSchemaObject item = titem;
if (item is XmlSchemaGroupRef)
item = GetRefGroupParticle ((XmlSchemaGroupRef)item);
if (item is XmlSchemaElement)
{
string ns;
XmlSchemaElement elem = (XmlSchemaElement) item;
XmlTypeMapping emap;
TypeData typeData = GetElementTypeData (typeQName, elem, null, out emap);
XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);
choices.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, -1));
if (elem.MaxOccurs > 1) multiValue = true;
}
else if (item is XmlSchemaAny)
{
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(typeof(XmlElement)));
einfo.IsUnnamedAnyElement = true;
choices.Add (einfo);
}
else if (item is XmlSchemaChoice) {
multiValue = ImportChoices (typeQName, member, choices, ((XmlSchemaChoice)item).Items) || multiValue;
}
else if (item is XmlSchemaSequence) {
multiValue = ImportChoices (typeQName, member, choices, ((XmlSchemaSequence)item).Items) || multiValue;
}
}
return multiValue;
}
void SetMemberValue (XmlTypeMapMember member, object ob, object value, bool isValueList)
{
var memberType = member.TypeData.Type;
if (value != null && !value.GetType().IsAssignableFrom (memberType))
value = XmlSerializationWriterInterpreter.ImplicitConvert (value, memberType);
if (isValueList)
((object[])ob)[member.GlobalIndex] = value;
else
member.SetValue (ob, value);
if (member.IsOptionalValueType)
member.SetValueSpecified (ob, true);
}
string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
{
if (isValueList) {
return null; //member.Index + " < " + ob + ".Length";
}
else if (member.DefaultValue != System.DBNull.Value) {
string mem = ob + ".@" + member.Name;
if (member.DefaultValue == null)
return mem + " != null";
else if (member.TypeData.SchemaType == SchemaTypes.Enum)
return mem + " != " + GetCast (member.TypeData, GetLiteral (member.DefaultValue));
else
return mem + " != " + GetLiteral (member.DefaultValue);
}
else if (member.IsOptionalValueType)
return ob + ".@" + member.Name + "Specified";
return null;
}
bool DefinedInBaseMap (XmlTypeMapping map, XmlTypeMapMember member)
{
if (((ClassMap)map.ObjectMap).FindMember (member.Name) != null)
return true;
else if (map.BaseMap != null)
return DefinedInBaseMap (map.BaseMap, member);
else
return false;
}
bool IsReadOnly (XmlTypeMapping map, XmlTypeMapMember member, TypeData memType, bool isValueList)
{
if (isValueList) return !memType.HasPublicConstructor;
else return member.IsReadOnly (map.TypeData.Type) || !memType.HasPublicConstructor;
}
string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
{
if (isValueList) {
if (member.IsOptionalValueType)
return ob + ".Length > " + Math.Max (member.GlobalIndex, member.SpecifiedGlobalIndex) + " && " + GetCast (typeof(bool), ob + "[" + member.SpecifiedGlobalIndex + "]");
else
return ob + ".Length > " + member.GlobalIndex;
}
else if (member.DefaultValue != System.DBNull.Value) {
string mem = ob + ".@" + member.Name;
if (member.DefaultValue == null)
return mem + " != null";
else if (member.TypeData.SchemaType == SchemaTypes.Enum)
return mem + " != " + GetCast (member.TypeData, GetLiteral (member.DefaultValue));
else
return mem + " != " + GetLiteral (member.DefaultValue);
}
else if (member.HasSpecified) {
var sb = new StringBuilder ();
sb.AppendFormat ("{0}.@{1}Specified", ob, member.Name);
if (member.HasShouldSerialize)
sb.AppendFormat (" && {0}.@ShouldSerialize{1} ()", ob, member.Name);
return sb.ToString ();
} else if (member.HasShouldSerialize)
return ob + ".@ShouldSerialize" + member.Name + " ()";
return null;
}
void GenerateSetMemberValue (XmlTypeMapMember member, string ob, string value, bool isValueList)
{
GenerateSetMemberValue (member, ob, value, isValueList, false);
}
CodeMemberField CreateFieldMember (XmlTypeMapMember member)
{
CodeMemberField codeField = new CodeMemberField (GetDomType (member.TypeData), member.Name);
codeField.Attributes = MemberAttributes.Public;
AddComments (codeField, member.Documentation);
if (member.DefaultValue != System.DBNull.Value)
GenerateDefaultAttribute (codeField, member.TypeData, member.DefaultValue);
return codeField;
}
void GenerateSetMemberValueFromAttr (XmlTypeMapMember member, string ob, string value, bool isValueList)
{
// Enumeration values specified in custom attributes are stored as integer
// values if the custom attribute property is of type object. So, it is
// necessary to convert to the enum type before asigning the value to the field.
if (member.TypeData.Type.IsEnum)
value = GetCast (member.TypeData.Type, value);
GenerateSetMemberValue (member, ob, value, isValueList, true);
}
XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form, XmlTypeMapping emap)
{
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);
einfo.ElementName = name;
einfo.Namespace = ns;
einfo.IsNullable = isNillable;
einfo.Form = form;
if (typeData.IsComplexType)
einfo.MappedType = emap;
return einfo;
}
bool GenerateReadArrayMemberHook (Type type, XmlTypeMapMember member, string index)
{
SetHookVar ("$INDEX", index);
return GenerateReadMemberHook (type, member);
}
bool IsReadOnly (XmlTypeMapMember member, object ob, bool isValueList)
{
if (isValueList) return false;
else return member.IsReadOnly (ob.GetType());
}
public void AddMember (XmlTypeMapMember member)
{
// If GlobalIndex has not been set, set it now
if (member.GlobalIndex == -1)
member.GlobalIndex = _allMembers.Count;
_allMembers.Add (member);
if (!(member.DefaultValue is System.DBNull) && member.DefaultValue != null) {
if (_membersWithDefault == null) _membersWithDefault = new ArrayList ();
_membersWithDefault.Add (member);
}
if (member.IsReturnValue)
_returnMember = member;
if (member is XmlTypeMapMemberAttribute)
{
XmlTypeMapMemberAttribute atm = (XmlTypeMapMemberAttribute)member;
if (_attributeMembers == null) _attributeMembers = new Hashtable();
string key = BuildKey (atm.AttributeName, atm.Namespace, -1);
if (_attributeMembers.ContainsKey (key))
throw new InvalidOperationException ("The XML attribute named '" + atm.AttributeName + "' from namespace '" + atm.Namespace + "' is already present in the current scope. Use XML attributes to specify another XML name or namespace for the attribute.");
member.Index = _attributeMembers.Count;
_attributeMembers.Add (key, member);
return;
}
else if (member is XmlTypeMapMemberFlatList)
{
RegisterFlatList ((XmlTypeMapMemberFlatList)member);
}
else if (member is XmlTypeMapMemberAnyElement)
{
XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement) member;
if (mem.IsDefaultAny) _defaultAnyElement = mem;
if (mem.TypeData.IsListType) RegisterFlatList (mem);
}
else if (member is XmlTypeMapMemberAnyAttribute)
{
_defaultAnyAttribute = (XmlTypeMapMemberAnyAttribute) member;
return;
}
else if (member is XmlTypeMapMemberNamespaces)
{
_namespaceDeclarations = (XmlTypeMapMemberNamespaces) member;
return;
}
if (member is XmlTypeMapMemberElement && ((XmlTypeMapMemberElement)member).IsXmlTextCollector)
{
if (_xmlTextCollector != null) throw new InvalidOperationException ("XmlTextAttribute can only be applied once in a class");
_xmlTextCollector = member;
}
if (_elementMembers == null) {
_elementMembers = new ArrayList();
_elements = new Hashtable();
}
member.Index = _elementMembers.Count;
_elementMembers.Add (member);
ICollection elemsInfo = ((XmlTypeMapMemberElement)member).ElementInfo;
foreach (XmlTypeMapElementInfo elem in elemsInfo)
{
string key = BuildKey (elem.ElementName, elem.Namespace, elem.ExplicitOrder);
if (_elements.ContainsKey (key))
throw new InvalidOperationException ("The XML element named '" + elem.ElementName + "' from namespace '" + elem.Namespace + "' is already present in the current scope. Use XML attributes to specify another XML name or namespace for the element.");
_elements.Add (key, elem);
}
if (member.TypeData.IsListType && member.TypeData.Type != null && !member.TypeData.Type.IsArray) {
if (_listMembers == null) _listMembers = new ArrayList ();
_listMembers.Add (member);
}
}
CodeTypeMember CreateFieldMember (CodeTypeDeclaration codeClass, XmlTypeMapMember member)
{
return CreateFieldMember (codeClass, GetDomType (member.TypeData, member.RequiresNullable), member.Name, member.DefaultValue, member.TypeData, member.Documentation);
}
XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form, int order)
{
if (typeData.IsComplexType)
return CreateElementInfo (ns, member, name, typeData, isNillable, form, GetTypeMapping (typeData), order);
else
return CreateElementInfo (ns, member, name, typeData, isNillable, form, null, order);
}
object GetMemberValue (XmlTypeMapMember member, object ob, bool isValueList)
{
if (isValueList) return ((object[])ob)[member.GlobalIndex];
else return member.GetValue (ob);
}
XmlTypeMapElementInfo CreateTextElementInfo (string ns, XmlTypeMapMember member, TypeData typeData)
{
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);
einfo.IsTextElement = true;
einfo.WrappedElement = false;
if (typeData.IsComplexType)
einfo.MappedType = GetTypeMapping (typeData);
return einfo;
}
bool MemberHasValue (XmlTypeMapMember member, object ob, bool isValueList)
{
if (isValueList) {
if (member.IsOptionalValueType && !member.GetValueSpecified (ob))
return false;
return member.GlobalIndex < ((object[])ob).Length;
}
else if (member.DefaultValue != System.DBNull.Value) {
object val = GetMemberValue (member, ob, isValueList);
if (val == null && member.DefaultValue == null) return false;
if (val != null && val.GetType().IsEnum)
{
if (val.Equals (member.DefaultValue)) return false;
Type t = Enum.GetUnderlyingType(val.GetType());
val = Convert.ChangeType (val, t);
}
if (val != null && val.Equals (member.DefaultValue)) return false;
}
else if (member.IsOptionalValueType)
return member.GetValueSpecified (ob);
return true;
}
public void AddMember(XmlTypeMapMember member)
{
// If GlobalIndex has not been set, set it now
if (member.GlobalIndex == -1)
{
member.GlobalIndex = _allMembers.Count;
}
_allMembers.Add(member);
if (!(member.DefaultValue is System.DBNull) && member.DefaultValue != null)
{
if (_membersWithDefault == null)
{
_membersWithDefault = new ArrayList();
}
_membersWithDefault.Add(member);
}
if (member.IsReturnValue)
{
_returnMember = member;
}
if (member is XmlTypeMapMemberAttribute)
{
XmlTypeMapMemberAttribute atm = (XmlTypeMapMemberAttribute)member;
if (_attributeMembers == null)
{
_attributeMembers = new Hashtable();
}
string key = BuildKey(atm.AttributeName, atm.Namespace, -1);
if (_attributeMembers.ContainsKey(key))
{
throw new InvalidOperationException("The XML attribute named '" + atm.AttributeName + "' from namespace '" + atm.Namespace + "' is already present in the current scope. Use XML attributes to specify another XML name or namespace for the attribute.");
}
member.Index = _attributeMembers.Count;
_attributeMembers.Add(key, member);
return;
}
else if (member is XmlTypeMapMemberFlatList)
{
RegisterFlatList((XmlTypeMapMemberFlatList)member);
}
else if (member is XmlTypeMapMemberAnyElement)
{
XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)member;
if (mem.IsDefaultAny)
{
_defaultAnyElement = mem;
}
if (mem.TypeData.IsListType)
{
RegisterFlatList(mem);
}
}
else if (member is XmlTypeMapMemberAnyAttribute)
{
_defaultAnyAttribute = (XmlTypeMapMemberAnyAttribute)member;
return;
}
else if (member is XmlTypeMapMemberNamespaces)
{
_namespaceDeclarations = (XmlTypeMapMemberNamespaces)member;
return;
}
if (member is XmlTypeMapMemberElement && ((XmlTypeMapMemberElement)member).IsXmlTextCollector)
{
if (_xmlTextCollector != null)
{
throw new InvalidOperationException("XmlTextAttribute can only be applied once in a class");
}
_xmlTextCollector = member;
}
if (_elementMembers == null)
{
_elementMembers = new ArrayList();
_elements = new Hashtable();
}
member.Index = _elementMembers.Count;
_elementMembers.Add(member);
ICollection elemsInfo = ((XmlTypeMapMemberElement)member).ElementInfo;
foreach (XmlTypeMapElementInfo elem in elemsInfo)
{
string key = BuildKey(elem.ElementName, elem.Namespace, elem.ExplicitOrder);
if (_elements.ContainsKey(key))
{
throw new InvalidOperationException("The XML element named '" + elem.ElementName + "' from namespace '" + elem.Namespace + "' is already present in the current scope. Use XML attributes to specify another XML name or namespace for the element.");
}
_elements.Add(key, elem);
}
if (member.TypeData.IsListType && member.TypeData.Type != null && !member.TypeData.Type.IsArray)
{
if (_listMembers == null)
{
_listMembers = new ArrayList();
}
_listMembers.Add(member);
}
}
bool IsReadOnly (XmlTypeMapMember member, TypeData memType, object ob, bool isValueList)
{
if (isValueList) return !memType.HasPublicConstructor;
else return member.IsReadOnly (ob.GetType()) || !memType.HasPublicConstructor;
}
