public XmlSerializerNamespaceResolver(XmlSerializerNamespaces serializerNamespaces) { serializerNamespaces.ToArray().ForEach(qns => { if (!qns.IsEmpty) { m_namespaces.Add(qns.Name, qns.Namespace); } }); }
protected void WriteStartElement(string name, string ns, Object o, bool writePrefixed, XmlSerializerNamespaces xmlns) { if (xmlns == null) { throw new ArgumentNullException("xmlns"); } WriteStartElement(name, ns, o, writePrefixed, xmlns.ToArray()); }
internal void Initialize (XmlWriter writer, XmlSerializerNamespaces nss) { this.writer = writer; if (nss != null) { namespaces = new ArrayList (); foreach (XmlQualifiedName ns in nss.ToArray()) if (ns.Name != "" && ns.Namespace != "") namespaces.Add (ns); } }
internal void Initialize(XmlWriter writer, XmlSerializerNamespaces nss) { this.writer = writer; if (nss != null) { namespaces = new ArrayList(); foreach (XmlQualifiedName ns in nss.ToArray()) { if (ns.Name != "" && ns.Namespace != "") { namespaces.Add(ns); } } } }
public XmlSerializerNamespaces(XmlSerializerNamespaces namespaces) : this(namespaces.ToArray()) { }
protected void WriteStartElement(string name, string ns, Object o, bool writePrefixed, XmlSerializerNamespaces xmlns) { WriteStartElement(name, ns, o, writePrefixed, xmlns != null ? xmlns.ToArray() : null); }
protected void WriteStartElement (string name, string ns, Object o, bool writePrefixed, XmlSerializerNamespaces xmlns) { WriteStartElement (name, ns, o, writePrefixed, xmlns != null ? xmlns.ToArray () : null); }
//--------------------------------------------------------------------------------------------------------------------- /// <summary>Creates an OpenSearchParameterValueSet instance based on the specified OpenSearch template and optional additional parameter information.</summary> /// <returns>A new OpenSearchParameterValueSet instance.</returns> /// <param name="template">An OpenSearch template URL.</param> /// <param name="origParams">An array of objects containing parameter information as defined by the OpenSearch Parameter extension.</returns> public static OpenSearchParameterValueSet FromOpenSearchDescription(string template, OpenSearchDescriptionUrlParameter[] origParams = null, XmlSerializerNamespaces namespaces = null) { OpenSearchParameterValueSet result = new OpenSearchParameterValueSet(); Dictionary<string, OpenSearchDescriptionUrlParameter> tempParameters = new Dictionary<string, OpenSearchDescriptionUrlParameter>(); Dictionary<string, string> tempNamespaces = null; if (origParams != null) { foreach (OpenSearchDescriptionUrlParameter origParam in origParams) tempParameters.Add(origParam.Name, origParam); } if (namespaces != null) { result.nameTable = new NameTable(); tempNamespaces = new Dictionary<string, string>(); foreach (XmlQualifiedName qn in namespaces.ToArray()) { tempNamespaces.Add(qn.Name, result.nameTable.Add(qn.Namespace)); } } // Make sure URL is valid Match match = urlRegex.Match(template); if (!match.Success) throw new OpenSearchException(String.Format("Invalid URL template: {0}", template)); // Split by query string parameter and add parameter definitions to the internal dictionaries: // parameters can be settable (e.g. name={key}, name={prefix:key}) or fixed (name=value) string[] items = match.Groups[1].Value.Split('&'); foreach (string item in items) { Match match2 = parameterDefinitionRegex.Match(item); if (!match2.Success) continue; string name = match2.Groups[1].Value; OpenSearchParameterDefinition paramDef; if (match2.Groups[3].Success) { // parameter is settable string identifier = match2.Groups[3].Value; string identifierNamespaceUri = null, identifierLocalName = null; if (tempNamespaces != null) { string[] parts = identifier.Split(':'); if (parts.Length == 2) { identifierNamespaceUri = tempNamespaces.ContainsKey(parts[0]) ? tempNamespaces[parts[0]] : null; if (identifierNamespaceUri != null) identifierLocalName = parts[1]; } } paramDef = new OpenSearchParameterDefinition(name, identifier, identifierNamespaceUri, identifierLocalName, tempParameters.ContainsKey(name) ? tempParameters[name] : null); result.parametersByIdentifier[identifier] = paramDef; } else { // parameter is fixed paramDef = new OpenSearchParameterDefinition(name); result.values[paramDef] = new string[] {match2.Groups[2].Value}; } result.parametersByName[paramDef.Name] = paramDef; } return result; }
protected void WriteStartElement (string name, string ns, Object o, bool writePrefixed, XmlSerializerNamespaces xmlns) { if (xmlns == null) throw new ArgumentNullException ("xmlns"); WriteStartElement (name, ns, o, writePrefixed, xmlns.ToArray ()); }
public XmlSerializerNamespaces(XmlSerializerNamespaces namespaces) : this(namespaces.ToArray()) {}
private String GetNamespace( XmlSerializerNamespaces namespaces ) { var sb = new StringBuilder(); foreach (XmlQualifiedName name in namespaces.ToArray()) { sb.Append( name.Namespace ); } return sb.ToString(); }
/// <summary> /// Initializes a new instance of the <see cref = "XmppSerializer" /> class. /// </summary> /// <param name = "elementName">Name of the element.</param> /// <param name = "schema">The schema.</param> /// <param name = "prefix">The prefix.</param> /// <param name = "defaultNamespace">The default namespace.</param> /// <param name = "serializerType">Type of the serializer.</param> private XmppSerializer(string elementName, string schema, string prefix, string defaultNamespace, Type serializerType) { this.elementName = elementName; this.serializerType = serializerType; this.schema = schema; this.prefix = prefix; this.defaultNamespace = defaultNamespace; serializer = new XmlSerializer(serializerType); nameTable = new NameTable(); nsMgr = new XmlNamespaceManager(nameTable); context = new XmlParserContext(nameTable, nsMgr, null, XmlSpace.None); namespaces = new XmlSerializerNamespaces(); namespaces.Add(prefix, defaultNamespace); foreach (XmlQualifiedName name in namespaces.ToArray()) { nsMgr.AddNamespace(name.Name, name.Namespace); } }