/// <summary> /// Initializes a new instance of the <see cref="ElementInfo"/> class. /// </summary> /// <param name="name">The Xml name of the element.</param> /// <param name="element">The element this class describes.</param> public ElementInfo(XmlNameInfo name, XliffElement element) : base(name) { ArgValidator.Create(element, "element").IsNotNull(); this.Element = element; }
/// <summary> /// Creates an instance of this class and populates its members using reflection on the specified /// <see cref="XliffElement"/> /// </summary> /// <param name="element">The element to reflect upon.</param> /// <returns>An instance of this class with information about the elements children and attributes.</returns> public static IElementInformation Create(XliffElement element) { ElementInformationFromReflection result; result = new ElementInformationFromReflection(); result.ChildMap = Reflector.GetSchemaChildren(element.GetType()); result.AttributeMap = Reflector.GetSchemaAttributes(element.GetType(), element as IInheritanceInfoProvider, element as IOutputResolver); return result; }
/// <summary> /// Validates that the <see cref="XliffElement"/> is not already used as a child for another /// <see cref="XliffElement"/>. If the element is a child, then an <see cref="ElementReuseException"/> /// is thrown. /// </summary> /// <param name="element">The element to check.</param> public static void ParentIsNull(XliffElement element) { if ((element != null) && (element.Parent != null)) { string message; message = string.Format(Properties.Resources.ArgValidator_ElementReused_Format, element.GetType().Name); throw new ElementReuseException(message); } }
/// <summary> /// Initializes a new instance of the <see cref="AttributeDataProvider"/> class. /// </summary> /// <param name="host">The element that hosts the attribute.</param> /// <param name="property">The name of the property associated with the attribute.</param> /// <param name="data">The raw attribute data being referenced by this class.</param> internal AttributeDataProvider(XliffElement host, string property, AttributeData data) : base(data) { Debug.Assert(host != null, "Host cannot be null."); Debug.Assert(data != null, "Data cannot be null."); Debug.Assert(!string.IsNullOrEmpty(property), "Property cannot be null."); this.data = data; this.host = host; this.property = property; }
/// <summary> /// Handler called when getting the custom Directionality value from a spanning code element. The value /// depends on the hierarchy of the ancestry. /// </summary> /// <param name="element">The element that the property is for.</param> /// <param name="property">The name of the property that is to be returned.</param> /// <returns>The custom value.</returns> private object LanguageInheritanceHandler(XliffElement element, string property) { object result; XliffDocument document; Debug.Assert(property == "Language", "Property name is not supported."); result = null; document = element.FindAncestor<XliffDocument>(); if (document != null) { result = document.SourceLanguage; } return result; }
/// <summary> /// Handler called when getting the custom Directionality value from a spanning code element. The value /// depends on the hierarchy of the ancestry. /// </summary> /// <param name="element">The element that the property is for.</param> /// <param name="property">The name of the property that is to be returned.</param> /// <returns>The custom value.</returns> private object LanguageInheritanceHandler(XliffElement element, string property) { object result; XliffDocument document; Debug.Assert(property == "Language", "Property name is not supported."); result = null; document = element.FindAncestor <XliffDocument>(); if (document != null) { result = document.TargetLanguage; } return(result); }
/// <summary> /// Deserializes text into XLIFF elements under the specified source element. /// </summary> /// <param name="source">The element to deserialize content to.</param> /// <param name="text">The text to deserialize.</param> public static void DeserializeText(XliffElement source, string text) { XliffReader reader; reader = new XliffReader(); reader.currentElementState = new ElementState(source); using (MemoryStream stream = new MemoryStream()) { // Don't wrap this in using because it may dispose of the stream which is one too many. TextWriter writer; writer = new StreamWriter(stream); writer.Write(text); writer.Flush(); stream.Seek(0, SeekOrigin.Begin); reader.reader = XmlReader.Create(stream); reader.DeserializeXmlContent(source); } }
/// <summary> /// Serializes an <see cref="XliffElement"/> to the stream using the specified Xml element Name. /// </summary> /// <param name="name">The name of the XmlElement to create.</param> /// <param name="element">The content to serialize.</param> private void SerializeImpl(string name, XliffElement element) { this.SerializeImpl(name, null, null, element, null); }
/// <summary> /// Deserializes the Xml content in the reader to the specified element. /// </summary> /// <param name="root">The element to insert deserialized XLIFF elements to.</param> private void DeserializeXmlContent(XliffElement root) { this.currentElementState = new ElementState(root); this.reader.MoveToContent(); do { switch (this.reader.NodeType) { case XmlNodeType.CDATA: if (this.currentElementState.Consumer is IResourceStringContentContainer) { this.currentElementState.Consumer.AddXliffChild( new XmlNameInfo((string)null), new CDataTag(this.reader.Value)); } break; case XmlNodeType.Comment: if (this.currentElementState.Consumer is IResourceStringContentContainer) { this.currentElementState.Consumer.AddXliffChild( new XmlNameInfo((string)null), new CommentTag(this.reader.Value)); } break; case XmlNodeType.Element: { ElementState currentState; currentState = this.currentElementState; this.DeserializeElement(); if (object.ReferenceEquals(this.currentElementState, currentState)) { // The element won't have any children so validate it. this.ValidateElementState(this.currentElementState); } } break; case XmlNodeType.EndElement: this.ValidateElementState(this.currentElementState); this.currentElementState = this.elementStack.Pop(); break; case XmlNodeType.Text: { int ordinal; ordinal = this.currentElementState.GetOrdinal(OutputItemType.Text, typeof(string)); if (ordinal < this.currentElementState.LastOrdinalRead) { string message; message = string.Format( Properties.Resources.XliffElement_ElementOutOfOrder_Format, this.currentElementState.Consumer.GetType().Name, typeof(string).Name, this.reader.NamespaceURI, this.reader.LocalName); throw new FormatException(message); } this.currentElementState.Consumer.SetXliffText(this.reader.Value); } break; case XmlNodeType.ProcessingInstruction: if (this.currentElementState.Consumer is IResourceStringContentContainer) { this.currentElementState.Consumer.AddXliffChild( new XmlNameInfo((string)null), new ProcessingInstructionTag(this.reader.Name, this.reader.Value)); } break; case XmlNodeType.SignificantWhitespace: // SignificantWhitespace is used when xml:space=preserve is added to an XmlElement and the // whitespace wasn't added by the Xml writer. if (this.currentElementState.Consumer is IResourceStringContentContainer) { IResourceStringContentContainer container; container = (IResourceStringContentContainer)this.currentElementState.Consumer; container.Text.Add(new PlainText(this.reader.Value)); } break; case XmlNodeType.Whitespace: // Whitespace was added by the Xml writer and is used between XmlElements so it should be ignored. break; } } while (this.reader.Read()); }
/// <summary> /// Verifies that the expected item is present and matches a set of items obtained from /// another target. The <typeparamref name="TItem"/> represents the type of items to compare from /// the enumerations. Only items of these types are compared. All other types are ignored. /// </summary> /// <typeparam name="TItem">The type of items to extract from <paramref name="expectedItem"/> /// and <paramref name="actualItems"/>.</typeparam> /// <param name="expectedItem">The expected item.</param> /// <param name="actualItems">The items to compare against the expected.</param> /// <param name="name">The XLIFF name the keys of the <paramref name="actualItems"/> should match.</param> public static void VerifyItems <TItem>(XliffElement expectedItem, IEnumerable <ElementInfo> actualItems, string name) where TItem : XliffElement { TestUtilities.VerifyItems <TItem>(new XliffElement[] { expectedItem }, actualItems, name); }
/// <summary> /// Deserializes the Xml content in the reader to the specified element. /// </summary> /// <param name="root">The element to insert deserialized XLIFF elements to.</param> private void DeserializeXmlContent(XliffElement root) { this.currentElementState = new ElementState(root); this.reader.MoveToContent(); do { switch (this.reader.NodeType) { case XmlNodeType.CDATA: if (this.currentElementState.Consumer is IResourceStringContentContainer) { this.currentElementState.Consumer.AddXliffChild( new XmlNameInfo((string)null), new CDataTag(this.reader.Value)); } break; case XmlNodeType.Comment: if (this.currentElementState.Consumer is IResourceStringContentContainer) { this.currentElementState.Consumer.AddXliffChild( new XmlNameInfo((string)null), new CommentTag(this.reader.Value)); } break; case XmlNodeType.Element: { ElementState currentState; currentState = this.currentElementState; this.DeserializeElement(); if (object.ReferenceEquals(this.currentElementState, currentState)) { // The element won't have any children so validate it. this.ValidateElementState(this.currentElementState); } } break; case XmlNodeType.EndElement: this.ValidateElementState(this.currentElementState); this.currentElementState = this.elementStack.Pop(); break; case XmlNodeType.Text: { int ordinal; ordinal = this.currentElementState.GetOrdinal(OutputItemType.Text, typeof(string)); if (ordinal < this.currentElementState.LastOrdinalRead) { string message; message = string.Format( Properties.Resources.XliffElement_ElementOutOfOrder_Format, this.currentElementState.Consumer.GetType().Name, typeof(string).Name, this.reader.NamespaceURI, this.reader.LocalName); throw new FormatException(message); } this.currentElementState.Consumer.SetXliffText(this.reader.Value); } break; case XmlNodeType.ProcessingInstruction: if (this.currentElementState.Consumer is IResourceStringContentContainer) { this.currentElementState.Consumer.AddXliffChild( new XmlNameInfo((string)null), new ProcessingInstructionTag(this.reader.Name, this.reader.Value)); } break; case XmlNodeType.SignificantWhitespace: // SignificantWhitespace is used when xml:space=preserve is added to an XmlElement and the // whitespace wasn't added by the Xml writer. if (this.currentElementState.Consumer is IResourceStringContentContainer) { IResourceStringContentContainer container; container = (IResourceStringContentContainer)this.currentElementState.Consumer; container.Text.Add(new PlainText(this.reader.Value)); } break; case XmlNodeType.Whitespace: // Whitespace was added by the Xml writer and is used between XmlElements so it should be ignored. break; } }while (this.reader.Read()); }