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; }