/// <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> /// Initializes a new instance of the <see cref="SchemaEntityAttribute"/> class. /// </summary> /// <param name="prefix">The prefix of the Xml attribute.</param> /// <param name="ns">The namespace of the Xml attribute.</param> /// <param name="localName">The local name of the Xml attribute.</param> /// <param name="requirement">Indicates whether the attribute is required in the XLIFF document.</param> public SchemaEntityAttribute(string prefix, string ns, string localName, Requirement requirement) { ArgValidator.Create(localName, "localName").IsNotNullOrWhitespace(); this.Name = new XmlNameInfo(prefix, ns, localName); this.Requirement = requirement; }
/// <summary> /// Initializes a new instance of the <see cref="GenericExtension"/> class. /// </summary> /// <param name="name">The name of the extension.</param> public GenericExtension(string name) { ArgValidator.Create(name, "name").IsNotNullOrWhitespace(); this.attributes = new Lazy <List <IExtensionAttribute> >(); this.children = new Lazy <List <ElementInfo> >(); this.Name = name; }
/// <summary> /// Initializes a new instance of the <see cref="SchemaChildAttribute"/> class. /// </summary> /// <param name="prefix">The prefix of the XLIFF fragment.</param> /// <param name="ns">The namespace of the XLIFF fragment.</param> /// <param name="localName">The local name of the XLIFF fragment.</param> /// <param name="type">The the type of the class associated with the XLIFF element.</param> public SchemaChildAttribute(string prefix, string ns, string localName, Type type) { // The value of localName may be null if the child is the inner text (ex. PlainText). ArgValidator.Create(localName, "name").IsNotWhitespaceOnly(); ArgValidator.Create(type, "type").IsNotNull(); this.ChildType = type; this.Name = new XmlNameInfo(prefix, ns, localName); }
/// <summary> /// Initializes a new instance of the <see cref="ExtensionNameInfo"/> class. /// </summary> /// <param name="prefix">The Xml prefix of the member used when writing information to a file.</param> /// <param name="ns">The namespace of the member.</param> /// <param name="localName">The local name of the member.</param> public ExtensionNameInfo(string prefix, string ns, string localName) { ArgValidator.Create(ns, "ns").IsNotNullOrWhitespace(); ArgValidator.Create(localName, "localName").IsNotNullOrWhitespace(); this.LocalName = localName; this.Namespace = ns; this.Prefix = prefix; }
/// <summary> /// Deserializes XLIFF content from a stream. /// </summary> /// <param name="stream">The stream to deserialize.</param> /// <returns>The <see cref="XliffDocument"/> that defines the root of the document.</returns> public XliffDocument Deserialize(Stream stream) { ArgValidator.Create(stream, "stream").IsNotNull(); using (XmlReader reader = XmlReader.Create(stream)) { return(this.Deserialize(reader)); } }
/// <summary> /// Initializes a new instance of the <see cref="InheritValueAttribute"/> class. /// </summary> /// <param name="inheritance">The type of inheritance.</param> /// <param name="ancestorType">The type of the ancestor to inherit from.</param> /// <param name="propertyName">The name of the property to get from the ancestor.</param> public InheritValueAttribute(Inheritance inheritance, Type ancestorType, string propertyName) { if (inheritance == Inheritance.AncestorType) { ArgValidator.Create(ancestorType, "ancestorType").IsNotNull(); } this.AncestorPropertyName = propertyName; this.AncestorType = ancestorType; this.Inheritance = inheritance; }
/// <summary> /// Converts a dictionary whose key and value are strings to a string where a comma delimits the key from the /// value, and a backslash delimits entries. /// </summary> /// <param name="value">The value to convert.</param> /// <returns>The string representation of the value that is used by XLIFF.</returns> public string Convert(object value) { IDictionary <string, string> styles; StringBuilder builder; ArgValidator.Create(value, "value").IsNotNull().IsOfType(typeof(IDictionary <string, string>)); styles = (IDictionary <string, string>)value; builder = new StringBuilder(); foreach (KeyValuePair <string, string> pair in styles) { string entry; string entryKey; string entryValue; try { XmlConvert.VerifyName(pair.Key); } catch (Exception e) { string message; message = string.Format(Properties.Resources.SubFormatStyleConverter_InvalidKey_Format, pair.Key); throw new FormatException(message, e); } entryKey = pair.Key.Replace( SubFormatStyleConverter.BackslashString, SubFormatStyleConverter.EscapedBackslash) .Replace( SubFormatStyleConverter.CommaString, SubFormatStyleConverter.EscapedComma); entryValue = pair.Value.Replace( SubFormatStyleConverter.BackslashString, SubFormatStyleConverter.EscapedBackslash) .Replace( SubFormatStyleConverter.CommaString, SubFormatStyleConverter.EscapedComma); entry = string.Join(SubFormatStyleConverter.CommaString, entryKey, entryValue); builder.Append(entry + SubFormatStyleConverter.BackslashString); } // Remove the trailing backslash. if (builder.Length > 0) { builder.Remove(builder.Length - 1, 1); } return(builder.Length > 0 ? builder.ToString() : null); }
/// <summary> /// Initializes a new instance of the <see cref="XliffReader"/> class. /// </summary> /// <param name="settings">Settings that determine how to read content.</param> public XliffReader(XliffReaderSettings settings) { GenericExtensionHandler defaultHandler; ArgValidator.Create(settings, "settings").IsNotNull(); this.elementStack = new Stack <ElementState>(); this.handlers = new Lazy <Dictionary <string, IExtensionHandler> >(); this.settings = settings; defaultHandler = new GenericExtensionHandler(); this.RegisterExtensionHandler(XliffReader.DefaultHandlerKey, defaultHandler); }
/// <summary> /// Selects an item matching the selection query. /// </summary> /// <param name="path">The selection query.</param> /// <returns>The object that was selected from the query path, or null if no match was found.</returns> /// <example>The value of <paramref name="path"/> might look something like "#g=group1/f=file1/u=unit1/n=note1" /// which is a full path from the document root.</example> public ISelectable Select(string path) { string selectionPath; ArgValidator.Create(path, "path").IsNotNull().StartsWith(Utilities.Constants.SelectorPathIndictator); selectionPath = Utilities.RemoveSelectorIndicator(path); if ((selectionPath.Length > 0) && (selectionPath[0] == Utilities.Constants.SelectorPathSeparator)) { // Strip the leading '/'. selectionPath = selectionPath.Substring(1); } return(this.SelectElement(selectionPath)); }
/// <summary> /// Registers a handler to call when reading non-native XLIFF elements and attributes to store extension data. /// </summary> /// <param name="ns">The namespace of items handled by the handler.</param> /// <param name="handler">The handler to add.</param> public void RegisterExtensionHandler(string ns, IExtensionHandler handler) { ArgValidator.Create(ns, "ns").IsNotNullOrWhitespace(); ArgValidator.Create(handler, "handler").IsNotNull(); if (this.handlers.Value.ContainsKey(ns)) { string message; message = string.Format(Properties.Resources.XliffReader_ExtensionAlreadyRegistered_Format, ns); throw new ExtensionAlreadyRegisteredException(message); } this.handlers.Value.Add(ns, handler); }
/// <summary> /// Converts a value from a native type to a string. /// </summary> /// <param name="value">The value to convert.</param> /// <returns>The string representation of the value that is used by XLIFF.</returns> public string Convert(object value) { string result; ArgValidator.Create(value, "value").IsNotNull().IsOfType(typeof(TData)); if (!this.Map.TryGetValue((TData)value, out result)) { string message; message = string.Format( Properties.Resources.ConverterBase_ValueNotImplemented_Format, value, this.GetType().Name); throw new NotImplementedException(message); } return(result); }
/// <summary> /// Serializes an <see cref="XliffDocument"/> to a stream. /// </summary> /// <param name="stream">The stream to write to.</param> /// <param name="document">The document to write.</param> public void Serialize(Stream stream, XliffDocument document) { XmlWriterSettings settings; ArgValidator.Create(stream, "stream").IsNotNull(); ArgValidator.Create(document, "document").IsNotNull(); settings = new XmlWriterSettings(); settings.Indent = this.settings.Indent; if (settings.Indent && (this.settings.IndentChars != null)) { settings.IndentChars = this.settings.IndentChars; } using (XmlWriter writer = XmlWriter.Create(stream, settings)) { this.Serialize(writer, document); } }
/// <summary> /// Initializes a new instance of the <see cref="ExplicitOutputDependencyAttribute"/> class. /// </summary> /// <param name="property">The name of the property the attributed property depends on.</param> public ExplicitOutputDependencyAttribute(string property) { ArgValidator.Create(property, "property").IsNotNull(); this.Property = property; }
/// <summary> /// Converts a hexidecimal string to an integer. /// </summary> /// <param name="value">The XLIFF string to convert.</param> /// <returns>The integer value of the string.</returns> object IValueConverter.ConvertBack(string value) { ArgValidator.Create(value, "value").IsNotNullOrWhitespace(); return(int.Parse(value, NumberStyles.HexNumber)); }
/// <summary> /// Converts an integer to a hexidecimal string. /// </summary> /// <param name="value">The value to convert.</param> /// <returns>The string representation of the value that is used by XLIFF.</returns> string IValueConverter.Convert(object value) { ArgValidator.Create(value, "value").IsNotNull().IsOfType(typeof(int)); return(string.Format("{0:X}", value).PadLeft(4, '0')); }
/// <summary> /// Selects an item matching the selection query. /// </summary> /// <param name="path">The selection query.</param> /// <returns>The object that was selected from the query path, or null if no match was found.</returns> /// <example>The value of <paramref name="path"/> might look something like "#g=group1/f=file1/u=unit1/n=note1" /// which is a relative path from the current object, not a full path from the document root.</example> public ISelectable Select(string path) { ArgValidator.Create(path, "path").IsNotNull().StartsWith(Utilities.Constants.SelectorPathIndictator); return(this.SelectElement(Utilities.RemoveSelectorIndicator(path))); }
/// <summary> /// Converts a string to a DateTime. /// </summary> /// <param name="value">The XLIFF string to convert.</param> /// <returns>The integer value of the string.</returns> object IValueConverter.ConvertBack(string value) { ArgValidator.Create(value, "value").IsNotNullOrWhitespace(); return(DateTime.Parse(value, null, DateTimeStyles.RoundtripKind)); }
/// <summary> /// Converts a DateTime to a string. /// </summary> /// <param name="value">The value to convert.</param> /// <returns>The string representation of the value that is used by XLIFF.</returns> string IValueConverter.Convert(object value) { ArgValidator.Create(value, "value").IsNotNull().IsOfType(typeof(DateTime)); return(((DateTime)value).ToString("O")); }
/// <summary> /// Initializes a new instance of the <see cref="ConverterAttribute"/> class. /// </summary> /// <param name="type">The type of the converter class.</param> public ConverterAttribute(Type type) { ArgValidator.Create(type, "type").IsNotNull(); this.TypeName = type.FullName; }
/// <summary> /// Initializes a new instance of the <see cref="HasValueIndicatorAttribute"/> class. /// </summary> /// <param name="type">The type of the indicator class.</param> public HasValueIndicatorAttribute(Type type) { ArgValidator.Create(type, "type").IsNotNull(); this.TypeName = type.FullName; }
/// <summary> /// Adds an element or text member to the extension data. /// </summary> /// <param name="child">The child to add.</param> public void AddChild(ElementInfo child) { ArgValidator.Create(child, "child").IsNotNull(); this.children.Value.Add(child); }
/// <summary> /// Initializes a new instance of the <see cref="XliffWriter"/> class. /// </summary> /// <param name="settings">The settings describing how to write content.</param> public XliffWriter(XliffWriterSettings settings) { ArgValidator.Create(settings, "settings").IsNotNull(); this.settings = settings; }
/// <summary> /// Converts an XLIFF string to a dictionary whose key and value are strings. /// </summary> /// <param name="value">The XLIFF string to convert.</param> /// <returns>The native type of the data.</returns> public object ConvertBack(string value) { IDictionary <string, string> result; int start; int length; string key; ArgValidator.Create(value, "value").IsNotWhitespaceOnly(); result = new Dictionary <string, string>(); start = 0; length = 0; key = null; for (int i = 0; i < value.Length; i++) { char c; c = value[i]; if (c == SubFormatStyleConverter.CommaChar) { // Delimiting the key from the value. if (key == null) { try { key = value.Substring(start, length); XmlConvert.VerifyName(key); } catch (Exception e) { string message; message = string.Format(Properties.Resources.SubFormatStyleConverter_InvalidKey_Format, key); throw new FormatException(message, e); } start = i + 1; length = 0; } else { string message; message = string.Format(Properties.Resources.SubFormatStyleConverter_CommaInValue_Format, key); throw new FormatException(message); } } else if (c == SubFormatStyleConverter.BackslashChar) { if ((i < (value.Length - 1)) && ((string.Format("{0}{1}", c, value[i + 1]) == SubFormatStyleConverter.EscapedBackslash) || (string.Format("{0}{1}", c, value[i + 1]) == SubFormatStyleConverter.EscapedComma))) { i++; length += 2; } else if (key != null) { // Delimiting entries. Overwrite duplicates. result[key] = value.Substring(start, length); key = null; start = i + 1; length = 0; } else { throw new FormatException(Properties.Resources.SubFormatStyleConverter_BackslashInKey); } } else { length++; } } if (length > 0) { if (key == null) { string message; message = string.Format( Properties.Resources.SubFormatStyleConverter_KeyWithoutValue_Format, value.Substring(start, length)); throw new FormatException(message); } else { // Overwrite duplicates. result[key] = value.Substring(start, length); } } return(result); }
/// <summary> /// Adds an attribute member to the extension data. /// </summary> /// <param name="attribute">The attribute to add.</param> public void AddAttribute(IExtensionAttribute attribute) { ArgValidator.Create(attribute, "attribute").IsNotNull(); this.attributes.Value.Add(attribute); }
/// <summary> /// Converts a string to a float. /// </summary> /// <param name="value">The XLIFF string to convert.</param> /// <returns>The float value of the string.</returns> object IValueConverter.ConvertBack(string value) { ArgValidator.Create(value, "value").IsNotNullOrWhitespace(); return(float.Parse(value)); }
/// <summary> /// Adds an element to this object as a child. /// </summary> /// <param name="element">The object to add.</param> public void AddChild(ElementInfo element) { ArgValidator.Create(element, "element").IsNotNull(); this.StoreChild(element); }
/// <summary> /// Converts an integer to a string. /// </summary> /// <param name="value">The value to convert.</param> /// <returns>The string representation of the value that is used by XLIFF.</returns> string IValueConverter.Convert(object value) { ArgValidator.Create(value, "value").IsNotNull().IsOfType(typeof(int)); return(value.ToString()); }