public abstract void AddSort ( object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType );
public override void AddSort( object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { CultureInfo cinfo; if (lang == null || lang == String.Empty) { cinfo = System.Threading.Thread.CurrentThread.CurrentCulture; } else { cinfo = new CultureInfo(lang); } if (order == XmlSortOrder.Descending) { if (caseOrder == XmlCaseOrder.LowerFirst) { caseOrder = XmlCaseOrder.UpperFirst; } else if (caseOrder == XmlCaseOrder.UpperFirst) { caseOrder = XmlCaseOrder.LowerFirst; } } AddSort(expr, new XPathComparerHelper(order, caseOrder, cinfo, dataType)); }
public XPathComparerHelper(XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { if (lang == null || lang == String.Empty) { this.cinfo = System.Threading.Thread.CurrentThread.CurrentCulture; } else { this.cinfo = new CultureInfo(lang); } if (order == XmlSortOrder.Descending) { if (caseOrder == XmlCaseOrder.LowerFirst) { caseOrder = XmlCaseOrder.UpperFirst; } else if (caseOrder == XmlCaseOrder.UpperFirst) { caseOrder = XmlCaseOrder.LowerFirst; } } this.order = order; this.caseOrder = caseOrder; this.dataType = dataType; }
public XPathComparerHelper(XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { if (lang == null) { _cinfo = CultureInfo.CurrentCulture; } else { try { _cinfo = new CultureInfo(lang); } catch (System.ArgumentException) { throw; // Throwing an XsltException would be a breaking change } } if (order == XmlSortOrder.Descending) { if (caseOrder == XmlCaseOrder.LowerFirst) { caseOrder = XmlCaseOrder.UpperFirst; } else if (caseOrder == XmlCaseOrder.UpperFirst) { caseOrder = XmlCaseOrder.LowerFirst; } } _order = order; _caseOrder = caseOrder; _dataType = dataType; }
public abstract void AddSort( object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType );
public Sort(int sortkey, String xmllang, XmlDataType datatype, XmlSortOrder xmlorder, XmlCaseOrder xmlcaseorder) { select = sortkey; lang = xmllang; dataType = datatype; order = xmlorder; caseOrder = xmlcaseorder; }
public XPathComparerHelper(XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { if (lang == null) { this.cinfo = Thread.CurrentThread.CurrentCulture; } else { try { this.cinfo = new CultureInfo(lang); } catch (ArgumentException) { throw; } } if (order == XmlSortOrder.Descending) { if (caseOrder == XmlCaseOrder.LowerFirst) { caseOrder = XmlCaseOrder.UpperFirst; } else if (caseOrder == XmlCaseOrder.UpperFirst) { caseOrder = XmlCaseOrder.LowerFirst; } } this.order = order; this.caseOrder = caseOrder; this.dataType = dataType; }
public Sort(int sortkey, string xmllang, XmlDataType datatype, XmlSortOrder xmlorder, XmlCaseOrder xmlcaseorder) { select = sortkey; lang = xmllang; dataType = datatype; order = xmlorder; caseOrder = xmlcaseorder; }
internal XPathComparerHelper( XmlSortOrder order, XmlCaseOrder caseOrder, CultureInfo cinfo, XmlDataType dataType) { _order = order; _caseOrder = caseOrder; _cinfo = cinfo; _dataType = dataType; }
public XPathSorter(object expr, XmlSortOrder orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType) { this._expr = XPathSorter.ExpressionFromObject(expr); this._type = dataType; if (dataType == XmlDataType.Number) { this._cmp = new XPathSorter.XPathNumberComparer(orderSort); } else { this._cmp = new XPathSorter.XPathTextComparer(orderSort, orderCase, lang); } }
public Sort(Compiler c) { c.CheckExtraAttributes("sort", "select", "lang", "data-type", "order", "case-order"); expr = c.CompileExpression(c.GetAttribute("select")); if (expr == null) { expr = c.CompileExpression("string(.)"); } langAvt = c.ParseAvtAttribute("lang"); dataTypeAvt = c.ParseAvtAttribute("data-type"); orderAvt = c.ParseAvtAttribute("order"); caseOrderAvt = c.ParseAvtAttribute("case-order"); // Precalc whatever we can lang = ParseLang(XslAvt.AttemptPreCalc(ref langAvt)); dataType = ParseDataType(XslAvt.AttemptPreCalc(ref dataTypeAvt)); order = ParseOrder(XslAvt.AttemptPreCalc(ref orderAvt)); caseOrder = ParseCaseOrder(XslAvt.AttemptPreCalc(ref caseOrderAvt)); }
internal override void Compile(Compiler compiler) { CompileAttributes(compiler); CheckEmpty(compiler); if (_selectKey == Compiler.InvalidQueryKey) { _selectKey = compiler.AddQuery("."); } _forwardCompatibility = compiler.ForwardCompatibility; _manager = compiler.CloneScopeManager(); _lang = ParseLang(PrecalculateAvt(ref _langAvt)); _dataType = ParseDataType(PrecalculateAvt(ref _dataTypeAvt), _manager); _order = ParseOrder(PrecalculateAvt(ref _orderAvt)); _caseOrder = ParseCaseOrder(PrecalculateAvt(ref _caseOrderAvt)); if (_langAvt == null && _dataTypeAvt == null && _orderAvt == null && _caseOrderAvt == null) { _sort = new Sort(_selectKey, _lang, _dataType, _order, _caseOrder); } }
internal override void Compile(Compiler compiler) { CompileAttributes(compiler); CheckEmpty(compiler); if (selectKey == Compiler.InvalidQueryKey) { selectKey = compiler.AddQuery("."); } this.forwardCompatibility = compiler.ForwardCompatibility; this.manager = compiler.CloneScopeManager(); this.lang = ParseLang(PrecalculateAvt(ref this.langAvt)); this.dataType = ParseDataType(PrecalculateAvt(ref this.dataTypeAvt), manager); this.order = ParseOrder(PrecalculateAvt(ref this.orderAvt)); this.caseOrder = ParseCaseOrder(PrecalculateAvt(ref this.caseOrderAvt)); if (this.langAvt == null && this.dataTypeAvt == null && this.orderAvt == null && this.caseOrderAvt == null) { this.sort = new Sort(this.selectKey, this.lang, this.dataType, this.order, this.caseOrder); } }
public override void AddSort( object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { CultureInfo cinfo; if (lang == null || lang == String.Empty) cinfo = System.Threading.Thread.CurrentThread.CurrentCulture; else cinfo = new CultureInfo(lang); if (order == XmlSortOrder.Descending) { if (caseOrder == XmlCaseOrder.LowerFirst) { caseOrder = XmlCaseOrder.UpperFirst; } else if (caseOrder == XmlCaseOrder.UpperFirst) { caseOrder = XmlCaseOrder.LowerFirst; } } AddSort(expr, new XPathComparerHelper(order, caseOrder, cinfo, dataType)); }
private static Object GetElementValue(XElement element, String name, XmlDataType dt, bool throwIfNotFound) { // find it... XElement child = element.Element(name); if(child != null) { if(dt == XmlDataType.String) return GetStringValue(child); else if(dt == XmlDataType.Boolean) return (bool)GetBooleanValue(child); else if(dt == XmlDataType.Int32) return (int)GetInt32Value(child); else throw new Exception(string.Format("Cannot handle '{0}'.", dt)); } else { if(throwIfNotFound) throw new Exception(string.Format("An element with name '{0}' was not found within an element with name '{1}'.", name, element.Name)); else return null; } }
private static Object GetElementValue(XElement element, String name, XmlDataType dt, bool throwIfNotFound) { // find it... XElement child = element.Element(name); if (child != null) { if (dt == XmlDataType.String) { return(GetStringValue(child)); } else if (dt == XmlDataType.Boolean) { return((bool)GetBooleanValue(child)); } else if (dt == XmlDataType.Int32) { return((int)GetInt32Value(child)); } else { throw new Exception(string.Format("Cannot handle '{0}'.", dt)); } } else { if (throwIfNotFound) { throw new Exception(string.Format("An element with name '{0}' was not found within an element with name '{1}'.", name, element.Name)); } else { return(null); } } }
public Sort(Compiler c) { c.CheckExtraAttributes("sort", new string[] { "select", "lang", "data-type", "order", "case-order" }); this.expr = c.CompileExpression(c.GetAttribute("select")); if (this.expr == null) { this.expr = c.CompileExpression("string(.)"); } this.langAvt = c.ParseAvtAttribute("lang"); this.dataTypeAvt = c.ParseAvtAttribute("data-type"); this.orderAvt = c.ParseAvtAttribute("order"); this.caseOrderAvt = c.ParseAvtAttribute("case-order"); this.lang = this.ParseLang(XslAvt.AttemptPreCalc(ref this.langAvt)); this.dataType = this.ParseDataType(XslAvt.AttemptPreCalc(ref this.dataTypeAvt)); this.order = this.ParseOrder(XslAvt.AttemptPreCalc(ref this.orderAvt)); this.caseOrder = this.ParseCaseOrder(XslAvt.AttemptPreCalc(ref this.caseOrderAvt)); }
/// <summary> /// Selects a node set using the specified XPath expression. /// </summary> public static XmlNodeList SelectNodesSorted(string expression, XmlNode source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlPrefix[] prefixes, params XPathVariable[] variables) { return(XmlNodeListFactory.CreateNodeList( SelectSorted(expression, source.CreateNavigator(), sortExpression, order, caseOrder, lang, dataType, prefixes, variables))); }
/// <summary> /// Selects a node set using the specified XPath expression. /// </summary> public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlPrefix[] prefixes, params XPathVariable[] variables) { XPathExpression expr = GetCompiledExpression(expression, source); XmlNamespaceManager ctx = PrepareContext(source, null, prefixes, variables); expr.SetContext(ctx); PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType, ctx); return(source.Select(expr)); }
private static void PrepareSort(XPathExpression expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlNamespaceManager context) { XPathExpression se; if (sortExpression is string) { se = GetCompiledExpression((string)sortExpression, source); } else if (sortExpression is XPathExpression) { se = (XPathExpression)sortExpression; } else { throw new XPathException(Properties.Resources.XPathCache_BadSortObject, null); } se.SetContext(context); expression.AddSort(se, order, caseOrder, lang, dataType); }
private static void PrepareSort(XPathExpression expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { if (sortExpression is string) { expression.AddSort( GetCompiledExpression((string)sortExpression, source), order, caseOrder, lang, dataType); } else if (sortExpression is XPathExpression) { expression.AddSort(sortExpression, order, caseOrder, lang, dataType); } else { throw new XPathException(Monobjc.Tools.Sdp.Properties.Resources.XPathCache_BadSortObject, null); } }
/// <summary> /// Selects a node set using the specified XPath expression. /// </summary> public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlNamespaceManager context) { XPathExpression expr = GetCompiledExpression(expression, source); expr.SetContext(context); PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType, context); return source.Select(expr); }
public void Add(object expr, XmlSortOrder orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType) { this._rgSorters.Add(new XPathSorter(expr, orderSort, orderCase, lang, dataType)); }
public void Add (object expr, XmlSortOrder orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType) { _rgSorters.Add (new XPathSorter (expr, orderSort, orderCase, lang, dataType)); }
public override void AddSort(object expr, XmlSortOrder orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType) { if (_sorters == null) _sorters = new XPathSorters (); _sorters.Add (expr, orderSort, orderCase, lang, dataType); }
public Sort (Compiler c) { c.CheckExtraAttributes ("sort", "select", "lang", "data-type", "order", "case-order"); expr = c.CompileExpression (c.GetAttribute ("select")); if (expr == null) expr = c.CompileExpression ("string(.)"); langAvt = c.ParseAvtAttribute ("lang"); dataTypeAvt = c.ParseAvtAttribute ("data-type"); orderAvt = c.ParseAvtAttribute ("order"); caseOrderAvt = c.ParseAvtAttribute ("case-order"); // Precalc whatever we can lang = ParseLang (XslAvt.AttemptPreCalc (ref langAvt)); dataType = ParseDataType (XslAvt.AttemptPreCalc (ref dataTypeAvt)); order = ParseOrder (XslAvt.AttemptPreCalc (ref orderAvt)); caseOrder = ParseCaseOrder (XslAvt.AttemptPreCalc (ref caseOrderAvt)); }
public override void AddSort(object expr, XmlSortOrder orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType) { if (this._sorters == null) { this._sorters = new XPathSorters(); } this._sorters.Add(expr, orderSort, orderCase, lang, dataType); }
public override void AddSort(Object expr, XmlSortOrder order, XmlCaseOrder caseOrder, String lang, XmlDataType dataType){}
public XPathSorter (object expr, IComparer cmp) { _expr = ExpressionFromObject (expr); _cmp = cmp; _type = XmlDataType.Text; }
public UnserializableDataTypeException(XmlDataType type) : this(type.NamespaceUri, type.TypeName) { }
public XPathSorter (object expr, XmlSortOrder orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType) { _expr = ExpressionFromObject (expr); _type = dataType; if (dataType == XmlDataType.Number) _cmp = new XPathNumberComparer (orderSort); else _cmp = new XPathTextComparer (orderSort, orderCase, lang); }
/// <summary> /// Selects a node set using the specified XPath expression. /// </summary> public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlPrefix[] prefixes, params XPathVariable[] variables) { XPathExpression expr = GetCompiledExpression(expression, source); XmlNamespaceManager ctx = PrepareContext(source, null, prefixes, variables); expr.SetContext(ctx); PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType, ctx); return source.Select(expr); }
public override void AddSort(Object expr, XmlSortOrder order, XmlCaseOrder caseOrder, String lang, XmlDataType dataType) { }
private static void PrepareSort(XPathExpression expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlNamespaceManager context) { XPathExpression se; if (sortExpression is string) { se = GetCompiledExpression((string)sortExpression, source); } else if (sortExpression is XPathExpression) { se = (XPathExpression)sortExpression; } else { throw new XPathException(Monobjc.Tools.Sdp.Properties.Resources.XPathCache_BadSortObject, null); } se.SetContext(context); expression.AddSort(se, order, caseOrder, lang, dataType); }
public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, params XPathVariable[] variables) { var expr = GetCompiledExpression(expression, source); expr.SetContext(PrepareContext(source, null, null, variables)); PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType); return(source.Select(expr)); }
private static void PrepareSort(XPathExpression expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlNamespaceManager context) { XPathExpression se; var s = sortExpression as string; if (s != null) { se = GetCompiledExpression(s, source); } else { var pathExpression = sortExpression as XPathExpression; if (pathExpression != null) { se = pathExpression; } else { throw new XPathException(Resources.XPathCache_BadSortObject, null); } } se.SetContext(context); expression.AddSort(se, order, caseOrder, lang, dataType); }
public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { var expr = GetCompiledExpression(expression, source); PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType); return(source.Select(expr)); }
/// <summary> /// Selects a node set using the specified XPath expression. /// </summary> public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlNamespaceManager context) { XPathExpression expr = GetCompiledExpression(expression, source); expr.SetContext(context); PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType, context); return(source.Select(expr)); }
public XPathComparerHelper(XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { if (lang == null) { this.cinfo = System.Threading.Thread.CurrentThread.CurrentCulture; } else { try { this.cinfo = new CultureInfo(lang); } catch (System.ArgumentException) { throw; } } if (order == XmlSortOrder.Descending) { if (caseOrder == XmlCaseOrder.LowerFirst) { caseOrder = XmlCaseOrder.UpperFirst; } else if (caseOrder == XmlCaseOrder.UpperFirst) { caseOrder = XmlCaseOrder.LowerFirst; } } this.order = order; this.caseOrder = caseOrder; this.dataType = dataType; }
/// <summary> /// Selects a node set using the specified XPath expression. /// </summary> public static XmlNodeList SelectNodesSorted(string expression, XmlNode source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlNamespaceManager context) { return(XmlNodeListFactory.CreateNodeList( SelectSorted(expression, source.CreateNavigator(), sortExpression, order, caseOrder, lang, dataType, context))); }
private static void PrepareSort(XPathExpression expression, XPathNavigator source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { if (sortExpression is string) { expression.AddSort( GetCompiledExpression((string)sortExpression, source), order, caseOrder, lang, dataType); } else if (sortExpression is XPathExpression) { expression.AddSort(sortExpression, order, caseOrder, lang, dataType); } else { throw new XPathException(Properties.Resources.XPathCache_BadSortObject, null); } }
public override void AddSort(object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) { AddSort(expr, new XPathComparerHelper(order, caseOrder, lang, dataType)); }
/// <summary> /// Selects a node set using the specified XPath expression. /// </summary> public static XmlNodeList SelectNodesSorted(string expression, XmlNode source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlNamespaceManager context) { return XmlNodeListFactory.CreateNodeList( SelectSorted(expression, source.CreateNavigator(), sortExpression, order, caseOrder, lang, dataType, context)); }
internal override void Compile(Compiler compiler) { CompileAttributes(compiler); CheckEmpty(compiler); if (selectKey == Compiler.InvalidQueryKey) { selectKey = compiler.AddQuery(Compiler.SelfQuery); } this.forwardCompatibility = compiler.ForwardCompatibility; this.manager = compiler.CloneScopeManager(); this.lang = ParseLang( PrecalculateAvt(ref this.langAvt )); this.dataType = ParseDataType( PrecalculateAvt(ref this.dataTypeAvt ), manager); this.order = ParseOrder( PrecalculateAvt(ref this.orderAvt )); this.caseOrder = ParseCaseOrder(PrecalculateAvt(ref this.caseOrderAvt)); if(this.langAvt == null && this.dataTypeAvt == null && this.orderAvt == null && this.caseOrderAvt == null) { this.sort = new Sort(this.selectKey, this.lang, this.dataType, this.order, this.caseOrder); } }
/// <summary> /// Selects a node set using the specified XPath expression. /// </summary> public static XmlNodeList SelectNodesSorted(string expression, XmlNode source, object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType, XmlPrefix[] prefixes, params XPathVariable[] variables) { return XmlNodeListFactory.CreateNodeList( SelectSorted(expression, source.CreateNavigator(), sortExpression, order, caseOrder, lang, dataType, prefixes, variables)); }
public XPathSorter(object expr, IComparer cmp) { this._expr = XPathSorter.ExpressionFromObject(expr); this._cmp = cmp; this._type = XmlDataType.Text; }