/// <summary> /// Writes all experiment graph attributes. /// </summary> /// <param name="writer">The writer.</param> /// <param name="flow">The flow.</param> public virtual void WriteGraphAttributes(XmlWriter writer, IExperiment flow) { string path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString()); System.IO.Directory.CreateDirectory(path); PropertyDescriptorCollection propertiesToWrite = TypeDescriptor.GetProperties(flow); foreach (PropertyDescriptor property in propertiesToWrite) { WriteXmlAttribute(writer, property, flow); } writer.WriteStartElement("References"); { if (flow.References != null) { var serializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(typeof(PackageSystem.PackageReference), null); foreach (IPackageReference reference in flow.References) { serializer.Serialize(writer, reference); } } } writer.WriteEndElement(); // Iterate again and write any elements that are pending. ALL attributes must be done first, or it results in invalid XML foreach (PropertyDescriptor property in propertiesToWrite) { WriteXmlElement(writer, property, flow); } }
void WritePatchedImport (XmlWriter writer, string newTarget) { /* If an import redirect exists, add a fake import to the project which will be used only if the original import doesn't exist. That is, the following import: <Import Project = "PathToReplace" /> will be converted into: <Import Project = "PathToReplace" Condition = "Exists('PathToReplace')"/> <Import Project = "ReplacementPath" Condition = "!Exists('PathToReplace')" /> */ // Modify the original import by adding a condition, so that this import will be used only // if the targets file exists. string cond = "Exists('" + target + "')"; if (!string.IsNullOrEmpty (Condition)) cond = "( " + Condition + " ) AND " + cond; writer.WriteStartElement ("Import", MSBuildProject.Schema); writer.WriteAttributeString ("Project", target); writer.WriteAttributeString ("Condition", cond); // Now add the fake import, with a condition so that it will be used only if the original // import does not exist. cond = "!Exists('" + target + "')"; if (!string.IsNullOrEmpty (Condition)) cond = "( " + Condition + " ) AND " + cond; writer.WriteStartElement ("Import", MSBuildProject.Schema); writer.WriteAttributeString ("Project", MSBuildProjectService.ToMSBuildPath (null, newTarget)); writer.WriteAttributeString ("Condition", cond); }
/// <summary> /// Applies the transformation from the reader to the writer /// </summary> /// <param name="reader"></param> /// <param name="writer"></param> public void Transform(XmlReader reader, XmlWriter writer) { Contract.Requires(reader != null); Contract.Requires(writer != null); while (reader.Read()) this.WriteNodeSingle(reader, writer); }
protected internal override void WriteXmlAttributes(XmlWriter writer) { if (Mode == VerticesEnumeratorMode.Range) { writer.WriteStartAttribute(StartField); writer.WriteValue(Start); writer.WriteEndAttribute(); writer.WriteStartAttribute(EndField); writer.WriteValue(End); writer.WriteEndAttribute(); writer.WriteStartAttribute(IncField); writer.WriteValue(Increment); writer.WriteEndAttribute(); } if (Mode != VerticesEnumeratorMode.All) { writer.WriteStartAttribute(ModeField); writer.WriteValue(Mode.ToString()); writer.WriteEndAttribute(); } base.WriteXmlAttributes(writer); }
void SanitizerNodeVisited(string nodeName, HtmlNode node, XmlWriter writer) { if (nodeName == "img" && node.Attributes["src"] != null && node.Attributes["src"].Value.StartsWith("cid:")) { // split src var src = node.Attributes["src"].Value.Split(new[] { ':' }, 2); if (src.Length == 2) { // Find inline attachment with given contentid var document = source.Documents.FirstOrDefault(d => d.ContentType == ContentType.Inline && d.ContentId == src[1]); if (document != null) { // Replace content-id url with filename var filename = ClientState.Current.Storage.ResolvePhysicalFilename(".", document.StreamName); node.Attributes["src"].Value = String.Format("file://{0}", filename); } } } else if (nodeName == "a" && node.Attributes["href"] != null) { var url = node.Attributes["href"].Value; // Clean href and inject javascript hook node.Attributes["href"].Value = String.Empty; writer.WriteAttributeString("onclick", String.Format("javascript:window.external.JsNavigate('{0}')", url)); } }
internal void WriteXml(XmlWriter writer) { writer.WriteAttributeString("classCode", ClassCode); its.TemplateSignpost(templateId + "#" + templateText, writer); writeXML(writer); if (assignedPerson != null) { writer.WriteStartElement("assignedPerson"); assignedPerson.TemplateId = templateId; assignedPerson.TemplateText = "assignedPerson"; assignedPerson.WriteXml(writer); writer.WriteEndElement(); } if (assignedDevice != null) { writer.WriteStartElement("assignedAuthoringDevice"); assignedDevice.TemplateId = templateId; assignedDevice.TemplateText = "assignedAuthoringDevice"; assignedDevice.WriteXml(writer); writer.WriteEndElement(); } if (representedOrganisation != null) { writer.WriteStartElement("representedOrganization"); representedOrganisation.TemplateId = templateId; representedOrganisation.TemplateText = "representedOrganization"; representedOrganisation.WriteXml(writer); writer.WriteEndElement(); } }
public override void SerializeNetwork(XmlWriter xmlWriter) { base.SerializeNetwork(xmlWriter); var expander = ControlElements[0] as SliderExpanderDouble; if (expander == null) return; xmlWriter.WriteStartAttribute("SliderMax"); xmlWriter.WriteValue(expander.SliderMax); xmlWriter.WriteEndAttribute(); xmlWriter.WriteStartAttribute("SliderMin"); xmlWriter.WriteValue(expander.SliderMin); xmlWriter.WriteEndAttribute(); xmlWriter.WriteStartAttribute("SliderValue"); xmlWriter.WriteValue(expander.SliderValue); xmlWriter.WriteEndAttribute(); xmlWriter.WriteStartAttribute("SliderStep"); xmlWriter.WriteValue(expander.SliderStep); xmlWriter.WriteEndAttribute(); xmlWriter.WriteStartAttribute("IsExpanded"); xmlWriter.WriteValue(expander.IsExpanded); xmlWriter.WriteEndAttribute(); }
public override void PrintQuery(XmlWriter w) { w.WriteStartElement(this.GetType().Name); w.WriteAttributeString("op", (isOr ? Operator.Op.OR : Operator.Op.AND).ToString()); opnd1.PrintQuery(w); opnd2.PrintQuery(w); w.WriteEndElement(); }
// Methods internal virtual void WriteTo( XmlWriter xmlWriter ) { xmlWriter.WriteStartElement( XmlDiff.Prefix, "descriptor", XmlDiff.NamespaceUri ); xmlWriter.WriteAttributeString( "opid", _operationID.ToString() ); xmlWriter.WriteAttributeString( "type", Type ); xmlWriter.WriteEndElement(); }
void IXmlSerializable.WriteXml(XmlWriter writer) { if (address != null) { address.WriteContentsTo(this.addressVersion, writer); } }
private static void WriteCLPSToXML(XmlWriter writer) { writer.WriteStartElement("CLPS"); uint clps_addr = m_Overlay.ReadPointer(0x60); uint clps_num = m_Overlay.Read16(clps_addr + 0x06); uint clps_size = (uint)(8 + (clps_num * 8)); byte[][] entries = new byte[clps_num][]; uint entry = clps_addr + 0x08; for (int i = 0; i < clps_num; i++) { entries[i] = new byte[8]; for (int j = 0; j < 8; j++) entries[i][j] = m_Overlay.Read8((uint)(entry + (j))); entry += 8; } for (int i = 0; i < entries.Length; i++) { writer.WriteStartElement("Entry"); writer.WriteStartElement("Value"); for (int j = 0; j < entries[i].Length; j++) writer.WriteElementString("Byte", entries[i][j].ToString()); writer.WriteEndElement(); writer.WriteEndElement(); } writer.WriteEndElement(); }
internal override void WriteTo(XmlWriter xml) { if (xml == null) return; xml.WriteComment(SR.GetString(SR.ServiceNameFromClient)); xml.WriteElementString("ServiceName", this.serviceBindingNameSentByClient); xml.WriteComment(SR.GetString(SR.ServiceNameOnService)); xml.WriteStartElement("ServiceNameCollection"); if (this.serviceNameCollectionConfiguredOnServer == null || this.serviceNameCollectionConfiguredOnServer.Count < 1) { xml.WriteElementString("ServiceName", this.defaultServiceBindingNameOfServer); } else { foreach (string serviceName in this.serviceNameCollectionConfiguredOnServer) { xml.WriteElementString("ServiceName", serviceName); } } xml.WriteFullEndElement(); }
public static void writeVertex(XmlWriter writer, Vector2D vert) { writer.WriteStartElement("vertex"); writer.WriteAttributeString("x", vert.x.ToString()); writer.WriteAttributeString("y", vert.y.ToString()); writer.WriteEndElement(); }
private static void WriteAlbum(XmlWriter writer, string albumTitle, string artist) { writer.WriteStartElement("album"); writer.WriteElementString("title", albumTitle); writer.WriteElementString("artist", artist); writer.WriteEndElement(); }
public override void Validate(XmlWriter output, SchematronRuntimeOptions options) { if (output == null) throw new ArgumentNullException("output"); if (options == null) throw new ArgumentNullException("options"); this.executable.Run(output, GetXsltOptions(options)); }
internal WrappedSerializer(Serialization.DataFormat dataFormat, string streamName, TextWriter output) : base(dataFormat, streamName) { this.firstCall = true; this.textWriter = output; Serialization.DataFormat dataFormat1 = this.format; switch (dataFormat1) { case Serialization.DataFormat.Text: { return; } case Serialization.DataFormat.XML: { XmlWriterSettings xmlWriterSetting = new XmlWriterSettings(); xmlWriterSetting.CheckCharacters = false; xmlWriterSetting.OmitXmlDeclaration = true; this.xmlWriter = XmlWriter.Create(this.textWriter, xmlWriterSetting); this.xmlSerializer = new Serializer(this.xmlWriter); return; } default: { return; } } }
protected virtual void WriteItem(XmlWriter writer, string baseUrl, SiteMapEntry item) { // <url> if (item.Url.StartsWith("http")) return; writer.WriteStartElement("url"); #if DEBUG2 if (!string.IsNullOrEmpty(item.ID)) writer.WriteElementString("id", item.ID); if (!string.IsNullOrEmpty(item.Title)) writer.WriteElementString("title", item.Title); if (!string.IsNullOrEmpty(item.Class)) writer.WriteElementString("class", item.Class); #endif writer.WriteElementString("loc", baseUrl + item.Url); if (item.LastModified.HasValue) writer.WriteElementString("lastmod", item.LastModified.Value.ToString("yyyy-MM-dd")); // Google doesn't like IS0 8601/W3C if (item.ChangeFrequency != ChangeFrequencyEnum.Undefined) writer.WriteElementString("changefreq", item.ChangeFrequency.ToString().ToLowerInvariant()); writer.WriteElementString("priority", item.Priority.ToString(CultureInfo.InvariantCulture)); // </url> writer.WriteEndElement(); }
public override void WritePaymentSpecificXml(XmlWriter xmlw) { if (_paymentMethod != null) { WriteSimpleElement(xmlw, "paymentmethod", _paymentMethod.Value); } }
internal override void WriteTo(XmlWriter xml) { TraceHelper.WriteTraceSource(xml, this.traceSource); TraceHelper.WriteEnId(xml, this.enTraceId); xml.WriteElementString("EnlistmentType", this.enType.ToString()); xml.WriteElementString("EnlistmentOptions", this.enOptions.ToString()); }
public override void WriteTo(XmlWriter w) { if (this.fSpecified) { base.WriteTo(w); } }
public override void Write(XmlWriter writer) { writer.WriteStartElement("sequence", NAMESPACE); foreach (var particles in Particles) particles.Write(writer); writer.WriteEndElement(); }
public void Serialize(DbDatabaseMapping databaseMapping, DbProviderInfo providerInfo, XmlWriter xmlWriter) { //Contract.Requires(xmlWriter != null); //Contract.Requires(databaseMapping != null); //Contract.Requires(providerInfo != null); Contract.Assert(databaseMapping.Model != null); Contract.Assert(databaseMapping.Database != null); _xmlWriter = xmlWriter; _databaseMapping = databaseMapping; _version = databaseMapping.Model.Version; _providerInfo = providerInfo; _namespace = _version == DataModelVersions.Version3 ? EdmXmlNamespaceV3 : EdmXmlNamespaceV2; _xmlWriter.WriteStartDocument(); using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version))) { WriteEdmxRuntime(); WriteEdmxDesigner(); } _xmlWriter.WriteEndDocument(); _xmlWriter.Flush(); }
private static void WriteReportFieldsXml(XmlWriter writer, Report report) { writer.WriteStartElement("Fields"); foreach (var field in report.Fields.Where(field => field.FieldType != FieldType.SectionRepeater)) { writer.WriteStartElement("Field-" + field.FieldType); writer.WriteAttributeString("Label", field.Label); if (field.FieldType != FieldType.CheckList && field.FieldType != FieldType.Location) { writer.WriteString(field.Value); } else { foreach (var item in field.ChildItems) { writer.WriteElementString(item.Item, item.Value); } } writer.WriteEndElement(); } writer.WriteEndElement(); }
public override void WriteXml(XmlWriter writer) { writer.WriteElementString("Format", Format); writer.WriteStartElement("OnlineResource", Namespace); OnlineResource.WriteXml(writer); writer.WriteEndElement(); }
public override void ToXml(XmlWriter xwriter) { xwriter.WriteStartElement("IirFilter"); xwriter.WriteElementString("CoefA", Util.ArrayToString(this.CoefA)); xwriter.WriteElementString("CoefB", Util.ArrayToString(this.CoefB)); xwriter.WriteEndElement(); }
/// <summary> /// Initializes a new instance of the <see cref="XmlExceptionFormatter"/> class using the specified <see cref="XmlWriter"/> and <see cref="Exception"/> objects. /// </summary> /// <param name="xmlWriter">The <see cref="XmlWriter"/> in which to write the XML.</param> /// <param name="exception">The <see cref="Exception"/> to format.</param> public XmlExceptionFormatter(XmlWriter xmlWriter, Exception exception) : base(exception) { if (xmlWriter == null) throw new ArgumentNullException("xmlWriter"); this.xmlWriter = xmlWriter; }
public static void WriteXml(XmlWriter writer, string key, Property value) { writer.WriteStartElement("PropertyEntry"); writer.WriteAttributeString("Key", key); var type = value.GetType(); try { var ser = GetSerializer(type); writer.WriteAttributeString("Type", type.AssemblyQualifiedName); ser.Serialize(writer, value); } catch (Exception ex) { Console.WriteLine("Serialization failed: " + ex.Message); Console.WriteLine("Property Key: " + key); Console.WriteLine("Property Value: " + value); Console.WriteLine("Property Type Name: " + type.Name); Console.WriteLine("Property Type Qualified Name: " + type.AssemblyQualifiedName); Console.WriteLine("Stacktrace: " + ex.StackTrace); } writer.WriteEndElement(); }
protected override void WriteTokenCore( XmlWriter writer, System.IdentityModel.Tokens.SecurityToken token ) { if ( writer == null ) throw new ArgumentNullException( "writer" ); if ( token == null ) throw new ArgumentNullException( "token" ); var c = token as SecurityToken; if ( c != null ) { writer.WriteStartElement( Constants.UsernameTokenPrefix, Constants.UsernameTokenName, Constants.UsernameTokenNamespace ); writer.WriteAttributeString( Constants.WsUtilityPrefix, Constants.IdAttributeName, Constants.WsUtilityNamespace, token.Id ); writer.WriteElementString( Constants.UsernameElementName, Constants.UsernameTokenNamespace, c.Info.Username ); writer.WriteStartElement( Constants.UsernameTokenPrefix, Constants.PasswordElementName, Constants.UsernameTokenNamespace ); writer.WriteAttributeString( Constants.TypeAttributeName, Constants.PasswordDigestType ); writer.WriteValue( c.GetPasswordDigestAsBase64() ); writer.WriteEndElement(); writer.WriteElementString( Constants.NonceElementName, Constants.UsernameTokenNamespace, c.GetNonceAsBase64() ); writer.WriteElementString( Constants.CreatedElementName, Constants.WsUtilityNamespace, c.GetCreatedAsString() ); writer.WriteEndElement(); writer.Flush(); } else base.WriteTokenCore( writer, token ); }
/// <summary> /// Generates output data in html form /// </summary> /// <param name="writer">output stream</param> /// <param name="indent">number of indentations</param> internal override void DrawHtml(XmlWriter writer, int indent) { if (Operation == XmlDiffViewOperation.Change) { Debug.Assert(this.declarationValue != ChangeInformation.Subset); XmlDiffView.HtmlStartRow(writer); this.DrawLinkNode(writer); XmlDiffView.HtmlStartCell(writer, indent); XmlDiffView.HtmlWriteString(writer, Tags.XmlDeclarationBegin); XmlDiffView.HtmlWriteString(writer, XmlDiffViewOperation.Change, this.declarationValue); XmlDiffView.HtmlWriteString(writer, Tags.XmlDeclarationEnd); XmlDiffView.HtmlEndCell(writer); XmlDiffView.HtmlStartCell(writer, indent); XmlDiffView.HtmlWriteString(writer, Tags.XmlDeclarationBegin); XmlDiffView.HtmlWriteString(writer, XmlDiffViewOperation.Change, ChangeInformation.Subset); XmlDiffView.HtmlWriteString(writer, Tags.XmlDeclarationEnd); XmlDiffView.HtmlEndCell(writer); XmlDiffView.HtmlEndRow(writer); } else { DrawHtmlNoChange(writer, indent); } }
public void Save(object obj, XmlWriter writer) { Type t = obj.GetType(); // writer.WriteStartElement(GetTypeName(t)); // System.Console.WriteLine("\tSave <{0}>",GetTypeName(t)); writer.WriteStartElement(obj.GetType().Name); PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(obj); PropertyInfo [] propertyInfos = new PropertyInfo[properties.Count]; for (int i = 0;i < properties.Count ; i ++){ propertyInfos[i] = t.GetProperty(properties[i].Name); } foreach (PropertyInfo info in propertyInfos) { if (info == null){ continue; } if (!info.CanRead) continue; if (info.GetCustomAttributes(typeof(XmlIgnoreAttribute), true).Length != 0) continue; object val = info.GetValue(obj, null); if (val == null) continue; if (val is ICollection) { // PropertyInfo pinfo = t.GetProperty(info.Name); // Console.WriteLine("pinfo {0}",pinfo.Name); if (info.Name.StartsWith("Contr")) { writer.WriteStartElement("Items"); } else { writer.WriteStartElement(info.Name); } foreach (object element in (ICollection)val) { Save(element, writer); } writer.WriteEndElement(); } else { if (!info.CanWrite) continue; TypeConverter c = TypeDescriptor.GetConverter(info.PropertyType); if (c.CanConvertFrom(typeof(string)) && c.CanConvertTo(typeof(string))) { try { writer.WriteElementString(info.Name, c.ConvertToInvariantString(val)); } catch (Exception ex) { writer.WriteComment(ex.ToString()); } } else if (info.PropertyType == typeof(Type)) { writer.WriteElementString(info.Name, ((Type)val).AssemblyQualifiedName); } else { // System.Diagnostics.Trace.WriteLine("Serialize Pagelayout"); // writer.WriteStartElement(info.Name); // Save(val, writer); // writer.WriteEndElement(); } } } writer.WriteEndElement(); }
void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter writer) { this.WriteXml(writer); }
protected override void WriteElements(Microsoft.VisualStudio.Modeling.SerializationContext serializationContext, Microsoft.VisualStudio.Modeling.ModelElement element, System.Xml.XmlWriter writer) { base.WriteElements(serializationContext, element, writer); // writer.WriteStartElement("custom"); // writer.WriteCData("my custom stuff here!"); // writer.WriteEndElement(); }
public override void buildXml(System.Xml.XmlWriter xmlWriter) { throw new NotImplementedException(); }
public void Save(System.Xml.XmlWriter xmlWriter) { XTypedServices.Save(xmlWriter, Untyped); }
public abstract void buildXml(System.Xml.XmlWriter xmlWriter);
/// <summary> /// Formats the token sequence to the writer /// </summary> /// <param name="writer"></param> /// <param name="tokens"></param> public void Format(System.Xml.XmlWriter writer, IEnumerable <Token <MarkupTokenType> > tokens) { if (writer == null) { throw new ArgumentNullException("writer"); } if (tokens == null) { throw new ArgumentNullException("tokens"); } int depth = 0; IStream <Token <MarkupTokenType> > stream = Stream <Token <MarkupTokenType> > .Create(tokens); Token <MarkupTokenType> token = stream.Peek(); try { while (!stream.IsCompleted) { switch (token.TokenType) { case MarkupTokenType.ElementBegin: { depth++; writer.WriteStartElement(token.Name.Prefix, token.Name.LocalName, token.Name.NamespaceUri); stream.Pop(); token = stream.Peek(); break; } case MarkupTokenType.ElementVoid: { writer.WriteStartElement(token.Name.Prefix, token.Name.LocalName, token.Name.NamespaceUri); stream.Pop(); token = stream.Peek(); while (!stream.IsCompleted && token.TokenType == MarkupTokenType.Attribute) { this.FormatAttribute(writer, stream); token = stream.Peek(); } writer.WriteEndElement(); break; } case MarkupTokenType.ElementEnd: { depth--; writer.WriteEndElement(); stream.Pop(); token = stream.Peek(); break; } case MarkupTokenType.Attribute: { this.FormatAttribute(writer, stream); token = stream.Peek(); break; } case MarkupTokenType.Primitive: { ITextFormattable <MarkupTokenType> formattable = token.Value as ITextFormattable <MarkupTokenType>; if (formattable != null) { formattable.Format(this, new XmlWriterAdapter(writer)); } else { writer.WriteString(token.ValueAsString()); } stream.Pop(); token = stream.Peek(); break; } default: { throw new TokenException <MarkupTokenType>( token, String.Format(ErrorUnexpectedToken, token.TokenType)); } } } while (depth-- > 0) { // auto close otherwise XmlWriter will choke writer.WriteEndElement(); } } catch (Exception ex) { throw new TokenException <MarkupTokenType>(token, ex.Message, ex); } }
/// <summary> /// Ctor /// </summary> /// <param name="writer"></param> public XmlWriterAdapter(System.Xml.XmlWriter writer) { this.Writer = writer; }
/// <summary> /// Serializes the DiceHandler object. /// </summary> /// <param name="writer">The xml writer to use when writing.</param> public void WriteXml(System.Xml.XmlWriter writer) { DiceState.WriteXml(writer); }
void System.Xml.Serialization.IXmlSerializable.WriteXml(Xml.XmlWriter writer) { writer.WriteValue(this.ToString()); }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 execute_Utilities = new GPUtilitiesClass(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } IGPParameter inputFeatureDatasetParameter = paramvalues.get_Element(in_featureDatasetParameterNumber) as IGPParameter; IGPValue inputFeatureDatasetGPValue = execute_Utilities.UnpackGPValue(inputFeatureDatasetParameter); IGPValue outputOSMFileGPValue = execute_Utilities.UnpackGPValue(paramvalues.get_Element(out_osmFileLocationParameterNumber)); // get the name of the feature dataset int fdDemlimiterPosition = inputFeatureDatasetGPValue.GetAsText().LastIndexOf("\\"); string nameOfFeatureDataset = inputFeatureDatasetGPValue.GetAsText().Substring(fdDemlimiterPosition + 1); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; System.Xml.XmlWriter xmlWriter = null; try { xmlWriter = XmlWriter.Create(outputOSMFileGPValue.GetAsText(), settings); } catch (Exception ex) { message.AddError(120021, ex.Message); return; } xmlWriter.WriteStartDocument(); xmlWriter.WriteStartElement("osm"); // start the osm root node xmlWriter.WriteAttributeString("version", "0.6"); // add the version attribute xmlWriter.WriteAttributeString("generator", "ArcGIS Editor for OpenStreetMap"); // add the generator attribute // write all the nodes // use a feature search cursor to loop through all the known points and write them out as osm node IFeatureClassContainer osmFeatureClasses = execute_Utilities.OpenDataset(inputFeatureDatasetGPValue) as IFeatureClassContainer; if (osmFeatureClasses == null) { message.AddError(120022, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), inputFeatureDatasetParameter.Name)); return; } IFeatureClass osmPointFeatureClass = osmFeatureClasses.get_ClassByName(nameOfFeatureDataset + "_osm_pt"); if (osmPointFeatureClass == null) { message.AddError(120023, string.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_no_pointfeatureclass"), nameOfFeatureDataset + "_osm_pt")); return; } // check the extension of the point feature class to determine its version int internalOSMExtensionVersion = osmPointFeatureClass.OSMExtensionVersion(); IFeatureCursor searchCursor = null; System.Xml.Serialization.XmlSerializerNamespaces xmlnsEmpty = new System.Xml.Serialization.XmlSerializerNamespaces(); xmlnsEmpty.Add("", ""); message.AddMessage(resourceManager.GetString("GPTools_OSMGPExport2OSM_exporting_pts_msg")); int pointCounter = 0; string nodesExportedMessage = String.Empty; // collect the indices for the point feature class once int pointOSMIDFieldIndex = osmPointFeatureClass.Fields.FindField("OSMID"); int pointChangesetFieldIndex = osmPointFeatureClass.Fields.FindField("osmchangeset"); int pointVersionFieldIndex = osmPointFeatureClass.Fields.FindField("osmversion"); int pointUIDFieldIndex = osmPointFeatureClass.Fields.FindField("osmuid"); int pointUserFieldIndex = osmPointFeatureClass.Fields.FindField("osmuser"); int pointTimeStampFieldIndex = osmPointFeatureClass.Fields.FindField("osmtimestamp"); int pointVisibleFieldIndex = osmPointFeatureClass.Fields.FindField("osmvisible"); int pointTagsFieldIndex = osmPointFeatureClass.Fields.FindField("osmTags"); using (ComReleaser comReleaser = new ComReleaser()) { searchCursor = osmPointFeatureClass.Search(null, false); comReleaser.ManageLifetime(searchCursor); System.Xml.Serialization.XmlSerializer pointSerializer = new System.Xml.Serialization.XmlSerializer(typeof(node)); IFeature currentFeature = searchCursor.NextFeature(); IWorkspace pointWorkspace = ((IDataset)osmPointFeatureClass).Workspace; while (currentFeature != null) { if (TrackCancel.Continue() == true) { // convert the found point feature into a osm node representation to store into the OSM XML file node osmNode = ConvertPointFeatureToOSMNode(currentFeature, pointWorkspace, pointTagsFieldIndex, pointOSMIDFieldIndex, pointChangesetFieldIndex, pointVersionFieldIndex, pointUIDFieldIndex, pointUserFieldIndex, pointTimeStampFieldIndex, pointVisibleFieldIndex, internalOSMExtensionVersion); pointSerializer.Serialize(xmlWriter, osmNode, xmlnsEmpty); // increase the point counter to later status report pointCounter++; currentFeature = searchCursor.NextFeature(); } else { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loader so far nodesExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_pts_exported_msg"), pointCounter); message.AddMessage(nodesExportedMessage); return; } } } nodesExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_pts_exported_msg"), pointCounter); message.AddMessage(nodesExportedMessage); // next loop through the line and polygon feature classes to export those features as ways // in case we encounter a multi-part geometry, store it in a relation collection that will be serialized when exporting the relations table IFeatureClass osmLineFeatureClass = osmFeatureClasses.get_ClassByName(nameOfFeatureDataset + "_osm_ln"); if (osmLineFeatureClass == null) { message.AddError(120023, string.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_no_linefeatureclass"), nameOfFeatureDataset + "_osm_ln")); return; } message.AddMessage(resourceManager.GetString("GPTools_OSMGPExport2OSM_exporting_ways_msg")); // as we are looping through the line and polygon feature classes let's collect the multi-part features separately // as they are considered relations in the OSM world List <relation> multiPartElements = new List <relation>(); System.Xml.Serialization.XmlSerializer waySerializer = new System.Xml.Serialization.XmlSerializer(typeof(way)); int lineCounter = 0; int relationCounter = 0; string waysExportedMessage = String.Empty; using (ComReleaser comReleaser = new ComReleaser()) { searchCursor = osmLineFeatureClass.Search(null, false); comReleaser.ManageLifetime(searchCursor); IFeature currentFeature = searchCursor.NextFeature(); // collect the indices for the point feature class once int lineOSMIDFieldIndex = osmLineFeatureClass.Fields.FindField("OSMID"); int lineChangesetFieldIndex = osmLineFeatureClass.Fields.FindField("osmchangeset"); int lineVersionFieldIndex = osmLineFeatureClass.Fields.FindField("osmversion"); int lineUIDFieldIndex = osmLineFeatureClass.Fields.FindField("osmuid"); int lineUserFieldIndex = osmLineFeatureClass.Fields.FindField("osmuser"); int lineTimeStampFieldIndex = osmLineFeatureClass.Fields.FindField("osmtimestamp"); int lineVisibleFieldIndex = osmLineFeatureClass.Fields.FindField("osmvisible"); int lineTagsFieldIndex = osmLineFeatureClass.Fields.FindField("osmTags"); int lineMembersFieldIndex = osmLineFeatureClass.Fields.FindField("osmMembers"); IWorkspace lineWorkspace = ((IDataset)osmLineFeatureClass).Workspace; while (currentFeature != null) { if (TrackCancel.Continue() == false) { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loaded so far waysExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_ways_exported_msg"), lineCounter); message.AddMessage(waysExportedMessage); return; } //test if the feature geometry has multiple parts IGeometryCollection geometryCollection = currentFeature.Shape as IGeometryCollection; if (geometryCollection != null) { if (geometryCollection.GeometryCount == 1) { // convert the found polyline feature into a osm way representation to store into the OSM XML file way osmWay = ConvertFeatureToOSMWay(currentFeature, lineWorkspace, osmPointFeatureClass, pointOSMIDFieldIndex, lineTagsFieldIndex, lineOSMIDFieldIndex, lineChangesetFieldIndex, lineVersionFieldIndex, lineUIDFieldIndex, lineUserFieldIndex, lineTimeStampFieldIndex, lineVisibleFieldIndex, internalOSMExtensionVersion); waySerializer.Serialize(xmlWriter, osmWay, xmlnsEmpty); // increase the line counter for later status report lineCounter++; } else { relation osmRelation = ConvertRowToOSMRelation((IRow)currentFeature, lineWorkspace, lineTagsFieldIndex, lineOSMIDFieldIndex, lineChangesetFieldIndex, lineVersionFieldIndex, lineUIDFieldIndex, lineUserFieldIndex, lineTimeStampFieldIndex, lineVisibleFieldIndex, lineMembersFieldIndex, internalOSMExtensionVersion); multiPartElements.Add(osmRelation); // increase the line counter for later status report relationCounter++; } } currentFeature = searchCursor.NextFeature(); } } IFeatureClass osmPolygonFeatureClass = osmFeatureClasses.get_ClassByName(nameOfFeatureDataset + "_osm_ply"); IFeatureWorkspace commonWorkspace = ((IDataset)osmPolygonFeatureClass).Workspace as IFeatureWorkspace; if (osmPolygonFeatureClass == null) { message.AddError(120024, string.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_no_polygonfeatureclass"), nameOfFeatureDataset + "_osm_ply")); return; } using (ComReleaser comReleaser = new ComReleaser()) { searchCursor = osmPolygonFeatureClass.Search(null, false); comReleaser.ManageLifetime(searchCursor); IFeature currentFeature = searchCursor.NextFeature(); // collect the indices for the point feature class once int polygonOSMIDFieldIndex = osmPolygonFeatureClass.Fields.FindField("OSMID"); int polygonChangesetFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmchangeset"); int polygonVersionFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmversion"); int polygonUIDFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmuid"); int polygonUserFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmuser"); int polygonTimeStampFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmtimestamp"); int polygonVisibleFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmvisible"); int polygonTagsFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmTags"); int polygonMembersFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmMembers"); IWorkspace polygonWorkspace = ((IDataset)osmPolygonFeatureClass).Workspace; while (currentFeature != null) { if (TrackCancel.Continue() == false) { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loaded so far waysExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_ways_exported_msg"), lineCounter); message.AddMessage(waysExportedMessage); message.AddAbort(resourceManager.GetString("GPTools_toolabort")); return; } //test if the feature geometry has multiple parts IGeometryCollection geometryCollection = currentFeature.Shape as IGeometryCollection; if (geometryCollection != null) { if (geometryCollection.GeometryCount == 1) { // convert the found polyline feature into a osm way representation to store into the OSM XML file way osmWay = ConvertFeatureToOSMWay(currentFeature, polygonWorkspace, osmPointFeatureClass, pointOSMIDFieldIndex, polygonTagsFieldIndex, polygonOSMIDFieldIndex, polygonChangesetFieldIndex, polygonVersionFieldIndex, polygonUIDFieldIndex, polygonUserFieldIndex, polygonTimeStampFieldIndex, polygonVisibleFieldIndex, internalOSMExtensionVersion); waySerializer.Serialize(xmlWriter, osmWay, xmlnsEmpty); // increase the line counter for later status report lineCounter++; } else { relation osmRelation = ConvertRowToOSMRelation((IRow)currentFeature, polygonWorkspace, polygonTagsFieldIndex, polygonOSMIDFieldIndex, polygonChangesetFieldIndex, polygonVersionFieldIndex, polygonUIDFieldIndex, polygonUserFieldIndex, polygonTimeStampFieldIndex, polygonVisibleFieldIndex, polygonMembersFieldIndex, internalOSMExtensionVersion); multiPartElements.Add(osmRelation); // increase the line counter for later status report relationCounter++; } } currentFeature = searchCursor.NextFeature(); } } waysExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_ways_exported_msg"), lineCounter); message.AddMessage(waysExportedMessage); // now let's go through the relation table message.AddMessage(resourceManager.GetString("GPTools_OSMGPExport2OSM_exporting_relations_msg")); ITable relationTable = commonWorkspace.OpenTable(nameOfFeatureDataset + "_osm_relation"); if (relationTable == null) { message.AddError(120025, String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_no_relationTable"), nameOfFeatureDataset + "_osm_relation")); return; } System.Xml.Serialization.XmlSerializer relationSerializer = new System.Xml.Serialization.XmlSerializer(typeof(relation)); string relationsExportedMessage = String.Empty; using (ComReleaser comReleaser = new ComReleaser()) { ICursor rowCursor = relationTable.Search(null, false); comReleaser.ManageLifetime(rowCursor); IRow currentRow = rowCursor.NextRow(); // collect the indices for the relation table once int relationOSMIDFieldIndex = relationTable.Fields.FindField("OSMID"); int relationChangesetFieldIndex = relationTable.Fields.FindField("osmchangeset"); int relationVersionFieldIndex = relationTable.Fields.FindField("osmversion"); int relationUIDFieldIndex = relationTable.Fields.FindField("osmuid"); int relationUserFieldIndex = relationTable.Fields.FindField("osmuser"); int relationTimeStampFieldIndex = relationTable.Fields.FindField("osmtimestamp"); int relationVisibleFieldIndex = relationTable.Fields.FindField("osmvisible"); int relationTagsFieldIndex = relationTable.Fields.FindField("osmTags"); int relationMembersFieldIndex = relationTable.Fields.FindField("osmMembers"); IWorkspace polygonWorkspace = ((IDataset)osmPolygonFeatureClass).Workspace; while (currentRow != null) { if (TrackCancel.Continue() == false) { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loaded so far relationsExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_relations_exported_msg"), relationCounter); message.AddMessage(relationsExportedMessage); message.AddAbort(resourceManager.GetString("GPTools_toolabort")); return; } relation osmRelation = ConvertRowToOSMRelation(currentRow, (IWorkspace)commonWorkspace, relationTagsFieldIndex, relationOSMIDFieldIndex, relationChangesetFieldIndex, relationVersionFieldIndex, relationUIDFieldIndex, relationUserFieldIndex, relationTimeStampFieldIndex, relationVisibleFieldIndex, relationMembersFieldIndex, internalOSMExtensionVersion); relationSerializer.Serialize(xmlWriter, osmRelation, xmlnsEmpty); // increase the line counter for later status report relationCounter++; currentRow = rowCursor.NextRow(); } } // lastly let's serialize the collected multipart-geometries back into relation elements foreach (relation currentRelation in multiPartElements) { if (TrackCancel.Continue() == false) { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loaded so far relationsExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_relations_exported_msg"), relationCounter); message.AddMessage(relationsExportedMessage); return; } relationSerializer.Serialize(xmlWriter, currentRelation, xmlnsEmpty); relationCounter++; } relationsExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_relations_exported_msg"), relationCounter); message.AddMessage(relationsExportedMessage); xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document } catch (Exception ex) { message.AddError(120026, ex.Message); } }