/// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     foreach(var interceptorElement in Interceptors)
     {
         writer.WriteElement("interceptor", interceptorElement.SerializeContent);
     }
 }
 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     foreach(var policy in Policies)
     {
         writer.WriteElement("policy", policy.SerializeContent);
     }
 }
 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     foreach(var param in Parameters)
     {
         writer.WriteElement("param", param.SerializeContent);
     }
 }
 private void SerializeContainerConfiguringElements(XmlWriter writer)
 {
     foreach(var element in ConfiguringElements)
     {
         string tag = ExtensionElementMap.GetTagForExtensionElement(element);
         writer.WriteElement(tag, element.SerializeContent);
     }
 }
Example #5
0
 public override void WriteXml(XmlWriter writer)
 {
     // Write tag attributes
     base.WriteXml(writer);
     writer.WriteElement(PeptideSettings);
     writer.WriteElement(TransitionSettings);
     writer.WriteElement(DataSettings);
     if (MeasuredResults != null)
         writer.WriteElement(MeasuredResults);
     if (!DocumentRetentionTimes.IsEmpty)
         writer.WriteElement(DocumentRetentionTimes);
 }
Example #6
0
        public override void SerializeContent(XmlWriter writer)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(writer, "writer");

            writer.WriteAttributeString(NamePropertyName, this.Name);
            foreach (var matchingRuleElement in this.MatchingRules)
            {
                writer.WriteElement("matchingRule", matchingRuleElement.SerializeContent);
            }
            foreach (var callHandlerElement in this.CallHandlers)
            {
                writer.WriteElement("callHandler", callHandlerElement.SerializeContent);
            }
        }
Example #7
0
 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     writer.WriteAttributeString(NamePropertyName, Name);
     foreach(var matchingRuleElement in MatchingRules)
     {
         writer.WriteElement("matchingRule", matchingRuleElement.SerializeContent);
     }
     foreach(var callHandlerElement in CallHandlers)
     {
         writer.WriteElement("callHandler", callHandlerElement.SerializeContent);
     }
 }
Example #8
0
 private void SerializeInjectionMembers(XmlWriter writer)
 {
     foreach(var member in InjectionMembers)
     {
         writer.WriteElement(member.ElementName, member.SerializeContent);
     }
 }
Example #9
0
        public override void SerializeContent(XmlWriter writer)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(writer, "writer");

            writer.WriteAttributeString(TypePropertyName, TypeName);
            writer.WriteAttributeIfNotEmpty(MapToPropertyName, MapToName)
                .WriteAttributeIfNotEmpty(NamePropertyName, Name);

            if(!string.IsNullOrEmpty(Lifetime.TypeName))
            {
                writer.WriteElement("lifetime", Lifetime.SerializeContent);
            }

            SerializeInjectionMembers(writer);
        }
Example #10
0
        public void WriteXml(XmlWriter writer)
        {
            // Write attributes
            writer.WriteAttribute(ATTR.pick, Pick);
            if (RankId != null || _rankIdName != null)
            {
                // If libraries were never connected properly, then _rankIdName may still contain
                // the rank ID.
                writer.WriteAttribute(ATTR.rank_type, RankId != null ? RankId.Value : _rankIdName);
                writer.WriteAttributeNullable(ATTR.peptide_count, PeptideCount);
            }
            writer.WriteAttribute(ATTR.document_library, HasDocumentLibrary);

            // Write child elements
            var libraries = (_libraries.Count > 0 || _disconnectedLibraries == null ?
                _libraries : _disconnectedLibraries);

            if (libraries.Count > 0)
            {
                // writer.WriteElements(_libraries, LIBRARY_HELPERS);
                for (int i = 0; i < libraries.Count; i++)
                {
                    // First make sure it's not the document library
                    var spec = (!ReferenceEquals(libraries, _disconnectedLibraries) ? _librarySpecs[i] : null);
                    if (spec == null || !spec.IsDocumentLibrary)
                    {
                        // If there is a library, write it.  Otherwise, write the
                        // library spec.
                        var item = libraries[i];
                        if (item == null)
                        {
                            if (spec != null && !spec.IsDocumentLocal)
                            {
                                IXmlElementHelper<LibrarySpec> helper = XmlUtil.FindHelper(spec, LIBRARY_SPEC_HELPERS);
                                if (helper == null)
                                    throw new InvalidOperationException(
                                        Resources.
                                            PeptideLibraries_WriteXml_Attempt_to_serialize_list_containing_invalid_type);
                                writer.WriteElement(helper.ElementNames[0], spec);
                            }
                        }
                        else
                        {
                            IXmlElementHelper<Library> helper = XmlUtil.FindHelper(item, LIBRARY_HELPERS);
                            if (helper == null)
                                throw new InvalidOperationException(
                                    Resources.
                                        PeptideLibraries_WriteXml_Attempt_to_serialize_list_containing_invalid_type);
                            writer.WriteElement(helper.ElementNames[0], item);
                        }
                    }
                }
            }
        }
Example #11
0
        private void ExportCollada_NodeSub(XmlWriter xml, IReadOnlyList<string> boneNames, Kn5Node node) {
            xml.WriteStartElement("node");
            xml.WriteAttributeStringSafe("id", node.Name);
            xml.WriteAttributeStringSafe("sid", node.Name);
            xml.WriteAttributeStringSafe("name", node.Name);

            xml.WriteAttributeString("layer", node.Active ? "Visible" : "Hidden");
            xml.WriteAttributeString("type", node.NodeClass == Kn5NodeClass.Base && boneNames.Contains(node.Name) ? "JOINT" : "NODE");

            if (node.Children?.FirstOrDefault()?.NodeClass != Kn5NodeClass.SkinnedMesh) {
                xml.WriteElement("matrix",
                        "sid", "transform",
                        node.NodeClass == Kn5NodeClass.Base ? XmlWriterExtension.MatrixToCollada(node.Transform) : "1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0");
            }

            if (IsMultiMaterial(node) && node.Children != null) {
                xml.WriteStartElement("instance_geometry");
                xml.WriteAttributeStringSafe("url", $"#{node.Name}-mesh");
                ExportCollada_NodeSub_BindMaterial(xml, node.Children.Select(x => x.MaterialId).ToArray());
                xml.WriteEndElement();
            } else {
                ExportCollada_NodeSub_Inner(xml, boneNames, node);
            }

            xml.WriteEndElement(); // node
        }
Example #12
0
        private void ExportCollada_Mesh(XmlWriter xml, string name, IReadOnlyList<Kn5Node> unsorted) {
            xml.WriteStartElement("geometry");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh");
            xml.WriteAttributeStringSafe("name", name);

            xml.WriteStartElement("mesh");

            var nodes = unsorted.Count == 1 ? unsorted :
                    unsorted.OrderBy(x => int.Parse(x.Name.Split(new[] { "_SUB" }, StringSplitOptions.None).Last())).ToList();

            /* coordinates */
            var vertexCount = nodes.Sum(x => x.Vertices.Length);
            xml.WriteStartElement("source");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-positions");
            xml.WriteStartElement("float_array");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-positions-array");
            xml.WriteAttributeString("count", vertexCount * 3);
            xml.WriteString(nodes.SelectMany(x => x.Vertices).SelectMany(x => x.Co).JoinToString(" "));
            xml.WriteEndElement(); // float_array

            xml.WriteStartElement("technique_common");
            xml.WriteStartElement("accessor");
            xml.WriteAttributeStringSafe("source", $"#{name}-mesh-positions-array");
            xml.WriteAttributeString("count", vertexCount);
            xml.WriteAttributeString("stride", 3);

            xml.WriteElement("param",
                    "name", "X",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "Y",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "Z",
                    "type", "float");

            xml.WriteEndElement(); // accessor
            xml.WriteEndElement(); // technique_common
            xml.WriteEndElement(); // source

            /* normals */
            xml.WriteStartElement("source");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-normals");
            xml.WriteStartElement("float_array");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-normals-array");
            xml.WriteAttributeString("count", vertexCount * 3);
            xml.WriteString(nodes.SelectMany(x => x.Vertices).SelectMany(x => x.Normal).JoinToString(" "));
            xml.WriteEndElement(); // float_array

            xml.WriteStartElement("technique_common");
            xml.WriteStartElement("accessor");
            xml.WriteAttributeStringSafe("source", $"#{name}-mesh-normals-array");
            xml.WriteAttributeString("count", vertexCount);
            xml.WriteAttributeString("stride", "3");
            
            xml.WriteElement("param",
                    "name", "X",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "Y",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "Z",
                    "type", "float");

            xml.WriteEndElement(); // accessor
            xml.WriteEndElement(); // technique_common
            xml.WriteEndElement(); // source

            /* uv */
            xml.WriteStartElement("source");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-map-0");
            xml.WriteStartElement("float_array");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-map-0-array");
            xml.WriteAttributeString("count", vertexCount * 2);
            xml.WriteString(nodes.SelectMany(x => x.Vertices).SelectMany(x => new[] { x.Uv[0], -x.Uv[1] }).JoinToString(" "));
            xml.WriteEndElement(); // float_array

            xml.WriteStartElement("technique_common");
            xml.WriteStartElement("accessor");
            xml.WriteAttributeStringSafe("source", $"#{name}-mesh-map-0-array");
            xml.WriteAttributeString("count", vertexCount);
            xml.WriteAttributeString("stride", 2);

            xml.WriteElement("param",
                    "name", "S",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "T",
                    "type", "float");

            xml.WriteEndElement(); // accessor
            xml.WriteEndElement(); // technique_common
            xml.WriteEndElement(); // source

            /* vertices */
            xml.WriteStartElement("vertices");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-vertices");
            xml.WriteElement("input",
                    "semantic", "POSITION",
                    "source", $"#{name}-mesh-positions");
            xml.WriteEndElement();

            /* triangles */
            var offset = 0;
            foreach (var node in nodes) {
                xml.WriteStartElement("triangles");
                xml.WriteAttributeStringSafe("original_node", $"{node.Name}");
                xml.WriteAttributeStringSafe("material", $"{Materials.Values.ElementAt((int)node.MaterialId).Name}-material");
                xml.WriteAttributeString("count", node.Indices.Length / 3);

                xml.WriteElement("input",
                        "semantic", "VERTEX",
                        "source", $"#{name}-mesh-vertices",
                        "offset", 0);
                xml.WriteElement("input",
                        "semantic", "NORMAL",
                        "source", $"#{name}-mesh-normals",
                        "offset", 1);
                xml.WriteElement("input",
                        "semantic", "TEXCOORD",
                        "source", $"#{name}-mesh-map-0",
                        "offset", 2,
                        "set", 0);

                var inner = offset;
                xml.WriteElementString("p", node.Indices.SelectMany(x => new[] { x + inner, x + inner, x + inner }).JoinToString(" "));
                xml.WriteEndElement(); // triangles

                offset += node.Vertices.Length;
            }
            
            xml.WriteEndElement(); // mesh
            xml.WriteEndElement(); // geometry
        }
Example #13
0
        public override void SerializeContent(XmlWriter writer)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(writer, "writer");

            writer.WriteAttributeString(NamePropertyName, this.Name);
            writer.WriteAttributeIfNotEmpty(TypeNamePropertyName, this.TypeName);
            if (this.LifetimeIsPresent())
            {
                writer.WriteElement("lifetime", this.Lifetime.SerializeContent);
            }
            foreach (var injectionElement in this.Injection)
            {
                writer.WriteElement(injectionElement.ElementName, injectionElement.SerializeContent);
            }
        }
Example #14
0
        public override void SerializeContent(XmlWriter writer)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(writer, "writer");

            writer.WriteAttributeString(NamePropertyName, this.Name);
            foreach (var param in this.Parameters)
            {
                writer.WriteElement("param", param.SerializeContent);
            }
        }
Example #15
0
        /// <summary>
        /// Write the contents of this element to the given <see cref="XmlWriter"/>.
        /// </summary>
        /// <remarks>The caller of this method has already written the start element tag before
        /// calling this method, so deriving classes only need to write the element content, not
        /// the start or end tags.</remarks>
        /// <param name="writer">Writer to send XML content to.</param>
        public override void SerializeContent(XmlWriter writer)
        {
            writer.WriteAttributeString(TypePropertyName, TypeName);
            writer.WriteAttributeIfNotEmpty(MapToPropertyName, MapToName)
                .WriteAttributeIfNotEmpty(NamePropertyName, Name);

            if(!string.IsNullOrEmpty(Lifetime.TypeName))
            {
                writer.WriteElement("lifetime", Lifetime.SerializeContent);
            }

            SerializeInjectionMembers(writer);
        }
Example #16
0
 public void WriteXml(XmlWriter writer)
 {
     // Write child elements
     if (IsSerializable)
     {
         var helper = XmlUtil.FindHelper(PeakScoringModel, PEAK_SCORING_MODEL_SPEC_HELPERS);
         if (helper == null)
             throw new InvalidOperationException(Resources.PeptideLibraries_WriteXml_Attempt_to_serialize_list_containing_invalid_type);
         writer.WriteElement(helper.ElementNames[0], PeakScoringModel);
     }
 }
Example #17
0
 public void WriteXml(XmlWriter writer)
 {
     // Write child elements
     writer.WriteElement(Enzyme);
     writer.WriteElement(DigestSettings);
     if (!BackgroundProteome.IsNone)
         writer.WriteElement(BackgroundProteome);
     writer.WriteElement(Prediction);
     writer.WriteElement(Filter);
     writer.WriteElement(Libraries);
     writer.WriteElement(Modifications);
     if (Integration.IsSerializable)
         writer.WriteElement(Integration);
     if (!Equals(Quantification, QuantificationSettings.DEFAULT))
         writer.WriteElement(Quantification);
 }
Example #18
0
        public void WriteXml(XmlWriter writer)
        {
            // Write this bool whether it is true or false, to allow its absence
            // as a marker of needing default values.
            writer.WriteAttribute(ATTR.use_measured_rts, UseMeasuredRTs, !UseMeasuredRTs);
            writer.WriteAttributeNullable(ATTR.measured_rt_window, MeasuredRTWindow);

            writer.WriteAttribute(ATTR.use_spectral_library_drift_times, UseLibraryDriftTimes, !UseLibraryDriftTimes);
            writer.WriteAttributeNullable(ATTR.spectral_library_drift_times_resolving_power, LibraryDriftTimesResolvingPower);

            // Write child elements
            if (RetentionTime != null)
                writer.WriteElement(RetentionTime);
            if (DriftTimePredictor != null)
                writer.WriteElement(DriftTimePredictor);
        }
Example #19
0
        private void ExportCollada_NodeSub_BindMaterial(XmlWriter xml, params uint[] materialId) {
            xml.WriteStartElement("bind_material");
            xml.WriteStartElement("technique_common");

            foreach (var materialName in materialId.Select(u => Materials.Values.ElementAt((int)u).Name)) {
                xml.WriteElement("instance_material",
                        "symbol", $"{materialName}-material",
                        "target", $"#{materialName}-material");
            }
            
            xml.WriteEndElement(); // technique_common
            xml.WriteEndElement(); // bind_material
        }
Example #20
0
        public override void WriteXml(XmlWriter writer)
        {
            // Write tag attributes
            base.WriteXml(writer);
            writer.WriteAttribute(ATTR.use_for_retention_time_prediction, false);
            writer.WriteAttributeNullable(ATTR.analyte_concentration, AnalyteConcentration);
            if (null != SampleType && !Equals(SampleType, SampleType.DEFAULT))
            {
                writer.WriteAttribute(ATTR.sample_type, SampleType.Name);
            }

            // Write optimization element, if present
            if (OptimizationFunction != null)
            {
                IXmlElementHelper<OptimizableRegression> helper = XmlUtil.FindHelper(
                    OptimizationFunction, OPTIMIZATION_HELPERS);
                if (helper == null)
                    throw new InvalidOperationException(Resources.ChromatogramSet_WriteXml_Attempt_to_serialize_list_containing_invalid_type);
                writer.WriteElement(helper.ElementNames[0], OptimizationFunction);
            }

            int i = 0;
            foreach (var fileInfo in MSDataFileInfos)
            {
                writer.WriteStartElement(EL.sample_file);
                writer.WriteAttribute(ATTR.id, GetOrdinalSaveId(i++));
                writer.WriteAttribute(ATTR.file_path, fileInfo.FilePath);
                writer.WriteAttribute(ATTR.sample_name, fileInfo.FilePath.GetSampleOrFileName());
                if(fileInfo.RunStartTime != null)
                {
                    writer.WriteAttribute(ATTR.acquired_time, XmlConvert.ToString((DateTime) fileInfo.RunStartTime, "yyyy-MM-ddTHH:mm:ss")); // Not L10N
                }
                if(fileInfo.FileWriteTime != null)
                {
                    writer.WriteAttribute(ATTR.modified_time, XmlConvert.ToString((DateTime)fileInfo.FileWriteTime, "yyyy-MM-ddTHH:mm:ss")); // Not L10N
                }

                // instrument information
                WriteInstrumentConfigList(writer, fileInfo.InstrumentInfoList);

                writer.WriteEndElement();
            }
            SrmDocument.WriteAnnotations(writer, Annotations);
        }
 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     writer.WriteAttributeString(NamePropertyName, Name);
     writer.WriteAttributeIfNotEmpty(TypeNamePropertyName, TypeName);
     if(LifetimeIsPresent())
     {
         writer.WriteElement("lifetime", Lifetime.SerializeContent);
     }
     foreach(var injectionElement in Injection)
     {
         writer.WriteElement(injectionElement.ElementName, injectionElement.SerializeContent);
     }
 }
Example #22
0
 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     writer.WriteAttributeString(NamePropertyName, Name);
     foreach (var param in Parameters)
     {
         writer.WriteElement("param", param.SerializeContent);
     }
 }