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);
}
internal XPathComparerHelper(
XmlSortOrder order,
XmlCaseOrder caseOrder,
CultureInfo cinfo,
XmlDataType dataType) {
_order = order;
_caseOrder = caseOrder;
_cinfo = cinfo;
_dataType = 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)));
}
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;
}
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));
}
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);
}
}
/// <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 override void AddSort(object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType)
{
AddSort(expr, new XPathComparerHelper(order, caseOrder, lang, dataType));
}
public XPathSorter(object expr, IComparer cmp)
{
this._expr = XPathSorter.ExpressionFromObject(expr);
this._cmp = cmp;
this._type = XmlDataType.Text;
}
