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 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 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);
}
/// <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);
}
/// <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 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 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 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 override void AddSort(object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType)
{
AddSort(expr, new XPathComparerHelper(order, caseOrder, lang, dataType));
}
public override void AddSort(Object expr, XmlSortOrder order,
XmlCaseOrder caseOrder,
String lang, XmlDataType 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));
}
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));
}
public XPathTextComparer (XmlSortOrder orderSort, XmlCaseOrder orderCase, string strLang)
{
_orderCase = orderCase;
// FIXME: We have to set this in
// reverse order since currently
// we don't support collation.
_nMulCase = (orderCase == XmlCaseOrder.UpperFirst) ? -1 : 1;
_nMulSort = (orderSort == XmlSortOrder.Ascending) ? 1 : -1;
if (strLang == null || strLang == "")
_ci = CultureInfo.CurrentCulture; // TODO: defer until evaluation?
else
_ci = new CultureInfo (strLang);
}
/// <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 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;
}
/// <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,
params XPathVariable[] variables)
{
return(XmlNodeListFactory.CreateNodeList(
SelectSorted(expression, source.CreateNavigator(), sortExpression,
order, caseOrder, lang, dataType, variables)));
}
/// <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));
}
/// <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)));
}
/// <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);
}
internal XPathComparerHelper(
XmlSortOrder order,
XmlCaseOrder caseOrder,
CultureInfo cinfo,
XmlDataType dataType) {
_order = order;
_caseOrder = caseOrder;
_cinfo = cinfo;
_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(Monobjc.Tools.Sdp.Properties.Resources.XPathCache_BadSortObject, null);
}
}
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 (_sorters == null)
_sorters = new XPathSorters ();
_sorters.Add (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));
}
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);
}
}
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);
}
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);
}
}
public void Add(object expr, XmlSortOrder orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType)
{
this._rgSorters.Add(new XPathSorter(expr, orderSort, orderCase, lang, dataType));
}
