/// <summary>
 /// Writes the body of an object in the output
 /// </summary>
 public override void WriteObjectContent(System.Xml.XmlDictionaryWriter writer, object graph)
 {
     if (graph == null)
     {
         writer.WriteAttributeString("nil", "true");
     }
     else
     {
         using (MemoryStream ms = new MemoryStream())
         {
             using (ProtoWriter protoWriter = new ProtoWriter(ms, model, null))
             {
                 model.Serialize(key, graph, protoWriter);
             }
             byte[] buffer = ms.GetBuffer();
             writer.WriteBase64(buffer, 0, (int)ms.Length);
         }
     }
 }
Пример #2
0
		void IXmlSerializable.WriteXml(System.Xml.XmlWriter writer)
		{
			// Open the file.
			FileStream fs = new FileStream(serverFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
			long length = fs.Length;

			// Write file name.
			writer.WriteElementString("fileName", ns, Path.GetFileName(serverFilePath));

			// Write file size (useful for determining progress.)
			writer.WriteElementString("size", ns, length.ToString());

			// Start the file content.
			writer.WriteStartElement("content", ns);

			// Read 4 KB chunks and write that (Base64 encoded).
			int bufferSize = 4096;
			byte[] fileBytes = new byte[bufferSize];
			int readBytes = bufferSize;

			while (readBytes > 0)
			{
				readBytes = fs.Read(fileBytes, 0, bufferSize);
				writer.WriteStartElement("chunk", ns);
				writer.WriteBase64(fileBytes, 0, readBytes);
				writer.WriteEndElement();
				writer.Flush();

			}

			fs.Close();

			// End the XML.
			writer.WriteEndElement();
			writer.Flush();

		}
Пример #3
0
        /// <summary>
        /// Graph object <paramref name="o"/> onto stream <paramref name="s"/>
        /// </summary>
        public void Graph(System.Xml.XmlWriter s, object o, DatatypeR2FormatterGraphResult result)
        {
            // Get an instance ref
            ED instance_ed = (ED)o;

            // Do a base format
            ANYFormatter baseFormatter = new ANYFormatter();
            baseFormatter.Graph(s, o, result);

            // Null flavor
            if (((ANY)o).NullFlavor != null)
            {
                return;
            }

            // Attributes
            if (instance_ed.MediaType != null && instance_ed.Representation != EncapsulatedDataRepresentation.TXT)
                s.WriteAttributeString("mediaType", instance_ed.MediaType);
            if (instance_ed.Language != null)
                s.WriteAttributeString("language", instance_ed.Language);
            if (instance_ed.Compression != null)
                s.WriteAttributeString("compression", Util.ToWireFormat(instance_ed.Compression));
            if (instance_ed.IntegrityCheckAlgorithm != null)
                s.WriteAttributeString("integrityCheckAlgorithm", Util.ToWireFormat(instance_ed.IntegrityCheckAlgorithm));

            Encoding textEncoding = System.Text.Encoding.UTF8;

            // Representation of data
            if(instance_ed.Data != null && instance_ed.Data.Length > 0)
                switch(instance_ed.Representation)
                {
                    case EncapsulatedDataRepresentation.TXT:
                        s.WriteAttributeString("value", textEncoding.GetString(instance_ed.Data));
                        break;
                    case EncapsulatedDataRepresentation.B64:
                        s.WriteStartElement("data", "urn:hl7-org:v3");
                        s.WriteBase64(instance_ed.Data, 0, instance_ed.Data.Length);
                        s.WriteEndElement();// data
                        break;
                    case EncapsulatedDataRepresentation.XML:
                        s.WriteStartElement("xml", "urn:hl7-org:v3");
                        s.WriteRaw(instance_ed.XmlData.OuterXml);
                        s.WriteEndElement(); // xml
                        break;
                }

            // Elements
            if (instance_ed.Reference != null)
            {
                s.WriteStartElement("reference", "urn:hl7-org:v3");
                var hostResult = Host.Graph(s, instance_ed.Reference);
                result.Code = hostResult.Code;
                result.AddResultDetail(hostResult.Details);
                s.WriteEndElement();
            }
            if (instance_ed.IntegrityCheck != null && instance_ed.IntegrityCheck.Length > 0)
            {
                s.WriteStartElement("integrityCheck", "urn:hl7-org:v3");
                s.WriteBase64(instance_ed.IntegrityCheck, 0, instance_ed.IntegrityCheck.Length);
                s.WriteEndElement(); // intcheck
            }
            if (instance_ed.Thumbnail != null)
            {
                s.WriteStartElement("thumbnail", "urn:hl7-org:v3");
                var hostResult = Host.Graph(s, instance_ed.Thumbnail);
                result.Code = hostResult.Code;
                result.AddResultDetail(hostResult.Details);

                s.WriteEndElement();
            }
            if (instance_ed.Description != null)
            {
                s.WriteStartElement("description", "urn:hl7-org:v3");
                var hostResult = Host.Graph(s, instance_ed.Description);
                result.Code = hostResult.Code;
                result.AddResultDetail(hostResult.Details);
                s.WriteEndElement();
            }
            if (instance_ed.Translation != null && !instance_ed.Translation.IsNull)
            {
                foreach (var trans in instance_ed.Translation)
                {
                    s.WriteStartElement("translation", "urn:hl7-org:v3");
                    var hostResult = Host.Graph(s, trans);
                    result.Code = hostResult.Code;
                    result.AddResultDetail(hostResult.Details);
                    s.WriteEndElement(); // translation
                }
            }

        }
Пример #4
0
        /// <summary>
        /// Graph the object <paramref name="o"/> onto stream <paramref name="s"/>
        /// </summary>
        /// <param name="s">The XmlWriter to write the object to</param>
        /// <param name="o">The object to graph</param>
        public void Graph(System.Xml.XmlWriter s, object o, DatatypeFormatterGraphResult result)
        {
            // Get an instance ref
            ED instance_ed = (ED)o;

            // Do a base format
            ANYFormatter baseFormatter = new ANYFormatter();
            baseFormatter.Graph(s, o, result);

            // Null flavor
            if (((ANY)o).NullFlavor != null)
            {
                return;
            }

            // Attributes
            s.WriteAttributeString("representation", Util.ToWireFormat(instance_ed.Representation));
            if (instance_ed.MediaType != null)
                s.WriteAttributeString("mediaType", Util.ToWireFormat(instance_ed.MediaType));
            if (instance_ed.Language != null)
                s.WriteAttributeString("language", instance_ed.Language);
            if (instance_ed.Compression != null)
                s.WriteAttributeString("compression", Util.ToWireFormat(instance_ed.Compression));
            if (instance_ed.IntegrityCheck != null)
                s.WriteAttributeString("integrityCheck", Convert.ToBase64String(instance_ed.IntegrityCheck));
            if (instance_ed.Description != null)
                result.AddResultDetail(new UnsupportedDatatypeR1PropertyResultDetail(ResultDetailType.Warning, "Description", "ED", s.ToString()));
            if (instance_ed.IntegrityCheckAlgorithm != null)
            {
                // Incorrect representation of the SHA1 and SHA256 names in r1
                switch ((EncapsulatedDataIntegrityAlgorithm)instance_ed.IntegrityCheckAlgorithm)
                {
                    case EncapsulatedDataIntegrityAlgorithm.SHA1:
                        s.WriteAttributeString("integrityCheckAlgorithm", "SHA-1");
                        break;
                    case EncapsulatedDataIntegrityAlgorithm.SHA256:
                        s.WriteAttributeString("integrityCheckAlgorithm", "SHA-256");
                        break;
                }
            }

            // Elements
            if (instance_ed.Reference != null)
            {
                TELFormatter refFormatter = new TELFormatter();
                s.WriteStartElement("reference", "urn:hl7-org:v3");
                refFormatter.Graph(s, instance_ed.Reference, result);
                s.WriteEndElement();
            }
            if (instance_ed.Thumbnail != null)
            {
                EDFormatter thumbFormatter = new EDFormatter();
                s.WriteStartElement("thumbnail", "urn:hl7-org:v3");
                thumbFormatter.Graph(s, instance_ed.Thumbnail, result);
                s.WriteEndElement();
            }
            if (instance_ed.Translation != null)
                result.AddResultDetail(new UnsupportedDatatypeR1PropertyResultDetail(ResultDetailType.Warning, "Translation", "ED", s.ToString()));
            Encoding textEncoding = System.Text.Encoding.UTF8;

            // Value
            if (instance_ed.Data != null && instance_ed.Data.Length > 0)
            {
                if (instance_ed.Representation == EncapsulatedDataRepresentation.B64)
                    s.WriteBase64(instance_ed.Data, 0, instance_ed.Data.Length);
                else if (instance_ed.Representation == EncapsulatedDataRepresentation.TXT)
                    s.WriteString(textEncoding.GetString(instance_ed.Data));
                else
                {
                    char[] charBuffer = textEncoding.GetChars(instance_ed.Data);
                    s.WriteRaw(charBuffer, 0, charBuffer.Length);
                }
            }
        }
Пример #5
0
        protected override void WriteXmlBase(System.Xml.XmlWriter writer)
        {
            base.WriteXmlBase(writer);

            string xsiPrefix = RmXmlSerializer.UseXsiPrefix(writer);
            string openEhrPrefix = RmXmlSerializer.UseOpenEhrPrefix(writer);

            if (this.AlternateText != null)
                writer.WriteElementString(openEhrPrefix, "alternate_text", RmXmlSerializer.OpenEhrNamespace, this.AlternateText);
            if (this.Uri != null)
            {
                writer.WriteStartElement(openEhrPrefix, "uri", RmXmlSerializer.OpenEhrNamespace);
                if (this.Uri.GetType() == typeof(OpenEhr.RM.DataTypes.Uri.DvEhrUri))
                {
                    string ehrUriType = "DV_EHR_URI";
                    if(!string.IsNullOrEmpty(openEhrPrefix))
                        ehrUriType = openEhrPrefix + ":" + ehrUriType;
                    writer.WriteAttributeString(xsiPrefix, "type", RmXmlSerializer.XsiNamespace, ehrUriType);
                }
                this.Uri.WriteXml(writer);
                writer.WriteEndElement();
            }

            if (this.Data != null)
            {
                writer.WriteStartElement(openEhrPrefix, "data", RmXmlSerializer.OpenEhrNamespace);
                writer.WriteBase64(this.Data, 0, this.Data.Length);
                writer.WriteEndElement();
            }

            if (this.MediaType != null)
            {
                writer.WriteStartElement(openEhrPrefix, "media_type", RmXmlSerializer.OpenEhrNamespace);
                this.MediaType.WriteXml(writer);
                writer.WriteEndElement();
            }

            if(this.CompressionAlgorithm != null)
            {
                writer.WriteStartElement(openEhrPrefix, "compression_algorithm", RmXmlSerializer.OpenEhrNamespace);
                this.CompressionAlgorithm.WriteXml(writer);
                writer.WriteEndElement();
            }

            if (this.IntegrityCheck != null)
            {
                writer.WriteStartElement(openEhrPrefix, "integrity_check", RmXmlSerializer.OpenEhrNamespace);
                writer.WriteBase64(this.IntegrityCheck, 0, this.IntegrityCheck.Length);
                writer.WriteEndElement();
            }

            if (this.IntegrityCheckAlgorithm != null)
            {
                writer.WriteStartElement(openEhrPrefix, "integrity_check_algorithm", RmXmlSerializer.OpenEhrNamespace);
                this.IntegrityCheckAlgorithm.WriteXml(writer);
                writer.WriteEndElement();
            }

            writer.WriteElementString(openEhrPrefix, "size", RmXmlSerializer.OpenEhrNamespace, this.Size.ToString());

            if (this.Thumbnail != null)
            {
                writer.WriteStartElement(openEhrPrefix, "thumbnail", RmXmlSerializer.OpenEhrNamespace);
                this.Thumbnail.WriteXml(writer);
                writer.WriteEndElement();
            }
        }
Пример #6
0
 public void WriteXml(System.Xml.XmlWriter writer)
 {
     writer.WriteBase64(segment.Array, segment.Offset, segment.Count);
     writer.Flush();
 }
Пример #7
0
        public override void WriteAttributesAndContent(System.Xml.XmlTextWriter xmloutput)
        {
            // Write attributes

            string kindText;
            switch (kind) {
            case SpecialKind.FirstAid: kindText = "first-aid"; break;
            case SpecialKind.Water: kindText = "water"; break;
            case SpecialKind.OptCrossing: kindText = "optional-crossing-point"; break;
            case SpecialKind.RegMark: kindText = "registration-mark"; break;
            case SpecialKind.Forbidden: kindText = "forbidden-route"; break;
            case SpecialKind.Boundary: kindText = "boundary"; break;
            case SpecialKind.OOB: kindText = "out-of-bounds"; break;
            case SpecialKind.Dangerous: kindText = "dangerous-area"; break;
            case SpecialKind.WhiteOut: kindText = "white-out"; break;
            case SpecialKind.Text: kindText = "text"; break;
            case SpecialKind.Descriptions: kindText = "descriptions"; break;
            case SpecialKind.Image: kindText = "image"; break;
            case SpecialKind.Line: kindText = "line"; break;
            case SpecialKind.Rectangle: kindText = "rectangle"; break;
            default:
                Debug.Fail("bad kind"); kindText = "none";  break;
            }

            xmloutput.WriteAttributeString("kind", kindText);

            if (kind == SpecialKind.OptCrossing)
                xmloutput.WriteAttributeString("orientation", XmlConvert.ToString(orientation));

            // Write sub-elements
            if (text != null) {
                xmloutput.WriteElementString("text", text);
            }

            if (imageBitmap != null) {
                xmloutput.WriteStartElement("image-data");
                xmloutput.WriteAttributeString("format", Util.ImageFormatText(imageBitmap.RawFormat));
                MemoryStream stm = new MemoryStream();
                imageBitmap.Save(stm, imageBitmap.RawFormat);
                stm.Flush();
                byte[] bytes = stm.ToArray();
                xmloutput.WriteBase64(bytes, 0, bytes.Length);
                xmloutput.WriteEndElement();
            }

            if (kind == SpecialKind.Descriptions && numColumns > 1) {
                xmloutput.WriteStartElement("appearance");
                xmloutput.WriteAttributeString("columns", XmlConvert.ToString(numColumns));
                xmloutput.WriteEndElement();
            }

            if (kind == SpecialKind.Text) {
                xmloutput.WriteStartElement("font");
                xmloutput.WriteAttributeString("name", fontName);
                xmloutput.WriteAttributeString("bold", XmlConvert.ToString(fontBold));
                xmloutput.WriteAttributeString("italic", XmlConvert.ToString(fontItalic));
                xmloutput.WriteEndElement();
                xmloutput.WriteStartElement("appearance");
                xmloutput.WriteAttributeString("color", color.ToString());
                xmloutput.WriteEndElement();
            }

            if (kind == SpecialKind.Line || kind == SpecialKind.Rectangle) {
                xmloutput.WriteStartElement("appearance");
                switch (lineKind) {
                    case LineKind.Single: xmloutput.WriteAttributeString("line-kind", "single"); break;
                    case LineKind.Double: xmloutput.WriteAttributeString("line-kind", "double"); break;
                    case LineKind.Dashed: xmloutput.WriteAttributeString("line-kind", "dashed"); break;
                }
                xmloutput.WriteAttributeString("color", color.ToString());
                xmloutput.WriteAttributeString("line-width", XmlConvert.ToString(lineWidth));
                if (lineKind == LineKind.Double || lineKind == LineKind.Dashed)
                    xmloutput.WriteAttributeString("gap-size", XmlConvert.ToString(gapSize));
                if (lineKind == LineKind.Dashed)
                    xmloutput.WriteAttributeString("dash-size", XmlConvert.ToString(dashSize));
                if (kind == SpecialKind.Rectangle)
                    xmloutput.WriteAttributeString("corner-radius", XmlConvert.ToString(cornerRadius));
                xmloutput.WriteEndElement();
            }

            // Write locations
            foreach (PointF location in locations) {
                xmloutput.WriteStartElement("location");
                xmloutput.WriteAttributeString("x", XmlConvert.ToString(location.X));
                xmloutput.WriteAttributeString("y", XmlConvert.ToString(location.Y));
                xmloutput.WriteEndElement();
            }

            // write courses
            xmloutput.WriteStartElement("courses");
            if (allCourses) {
                xmloutput.WriteAttributeString("all", XmlConvert.ToString(true));
            }
            else {
                foreach (CourseDesignator courseDesignator in courses) {
                    xmloutput.WriteStartElement("course");
                    xmloutput.WriteAttributeString("course", XmlConvert.ToString(courseDesignator.CourseId.id));
                    if (!courseDesignator.AllParts)
                        xmloutput.WriteAttributeString("part", XmlConvert.ToString(courseDesignator.Part));
                    xmloutput.WriteEndElement();
                }
            }

            xmloutput.WriteEndElement();
        }