public abstract void AddSort(
object expr,
XmlSortOrder order,
XmlCaseOrder caseOrder,
string lang,
XmlDataType dataType
);
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;
}
/// <summary>
/// Selects a node set using the specified XPath expression and sort.
/// </summary>
/// <remarks>(object, IComparer)
/// See <see cref="XPathExpression.AddSort(object, IComparer)"/>.
/// </remarks>
public static XmlNodeList SelectNodesSorted(string expression, XmlNode source,
object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType)
{
return(XmlNodeListFactory.CreateNodeList(
SelectSorted(expression, source.CreateNavigator(), sortExpression,
order, caseOrder, lang, dataType)));
}
public void SortXml(string FirstChildName, string SelectNode, string SortNode, Sort.SortList MySort)
{
int mode = (int)MySort;
if (this._XmlDocument != null)
{
string xml = "<?xml version=\"1.0\" encoding=\"" + this.Encoding + "\"?><" + FirstChildName + ">";
XPathNavigator nav = this._XmlDocument.CreateNavigator();
XPathExpression expr;
expr = nav.Compile("descendant::" + SelectNode);
XmlSortOrder sort = mode == 0 ? XmlSortOrder.Ascending : XmlSortOrder.Descending;
expr.AddSort(SortNode, sort, XmlCaseOrder.None, "", XmlDataType.Text);
XPathNodeIterator iterator = nav.Select(expr);
while (iterator.MoveNext())
{
XmlNode node = ((IHasXmlNode)iterator.Current).GetNode();
xml += "<" + SelectNode + ">" + node.InnerXml + "</" + SelectNode + ">";
}
xml += "</" + FirstChildName + ">";
this._XmlDocument.LoadXml(xml);
}
}
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 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 XmlDocument SortXml(XmlDocument XmlDoc, string SelectSingleNode, string SelectNode, string SortNode, SortMode SortMode)
{
int mode = (int)SortMode;
if (XmlDoc != null)
{
XmlSortOrder sort = mode == 0 ? XmlSortOrder.Ascending : XmlSortOrder.Descending;
XmlDocument xmlDocCopy = new XmlDocument();
xmlDocCopy.LoadXml(XmlDoc.OuterXml);
xmlDocCopy.SelectSingleNode("//" + SelectSingleNode).RemoveAll();
XmlNode node = XmlDoc.SelectSingleNode("//" + SelectSingleNode);
XPathNavigator navigator = node.CreateNavigator();
XPathExpression selectExpression = navigator.Compile(string.Format("{0}/{1}", SelectNode, SortNode));
selectExpression.AddSort(".", sort, XmlCaseOrder.None, "", XmlDataType.Text);
XPathNodeIterator nodeIterator = navigator.Select(selectExpression);
while (nodeIterator.MoveNext())
{
XmlNode linkNode = XmlDoc.SelectSingleNode(string.Format("//{0}[{1}=\"{2}\"]", SelectNode, SortNode, nodeIterator.Current.Value));
XmlNode importedLinkNode = xmlDocCopy.ImportNode(linkNode, true);
xmlDocCopy.SelectSingleNode("//" + SelectSingleNode).AppendChild(importedLinkNode);
}
XmlDoc = xmlDocCopy;
}
return(XmlDoc);
}
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 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 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));
}
/// <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 orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType)
{
if (this._sorters == null)
{
this._sorters = new XPathSorters();
}
this._sorters.Add(expr, orderSort, orderCase, lang, dataType);
}
/// <summary>
/// Selects a node set using the specified XPath expression and sort.
/// </summary>
/// <remarks>
/// See <see cref="XPathExpression.AddSort(object, IComparer)"/>.
/// </remarks>
public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source,
object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType)
{
XPathExpression expr = GetCompiledExpression(expression, source);
PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType);
return(source.Select(expr));
}
public Sort(int sortkey, string xmllang, XmlDataType datatype, XmlSortOrder xmlorder, XmlCaseOrder xmlcaseorder)
{
select = sortkey;
lang = xmllang;
dataType = datatype;
order = xmlorder;
caseOrder = xmlcaseorder;
}
public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source,
object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType,
XmlNamespaceManager context)
{
var expr = GetCompiledExpression(expression, source);
expr.SetContext(context);
PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType, context);
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,
params XPathVariable[] variables)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(PrepareContext(source, null, null, variables));
PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType);
return(source.Select(expr));
}
internal XPathComparerHelper(
XmlSortOrder order,
XmlCaseOrder caseOrder,
CultureInfo cinfo,
XmlDataType dataType)
{
_order = order;
_caseOrder = caseOrder;
_cinfo = cinfo;
_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,
params XmlPrefix[] prefixes)
{
XPathExpression expr = GetCompiledExpression(expression, source);
XmlNamespaceManager ctx = PrepareContext(source, null, prefixes, null);
expr.SetContext(ctx);
PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType, ctx);
return(source.Select(expr));
}
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 XPathTextComparer(XmlSortOrder orderSort, XmlCaseOrder orderCase, string strLang)
{
this._orderCase = orderCase;
this._nMulCase = ((orderCase != XmlCaseOrder.UpperFirst) ? 1 : -1);
this._nMulSort = ((orderSort != XmlSortOrder.Ascending) ? -1 : 1);
if (strLang == null || strLang == string.Empty)
{
this._ci = CultureInfo.CurrentCulture;
}
else
{
this._ci = new CultureInfo(strLang);
}
}
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 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);
}
}
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);
}
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));
}
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));
}
public XPathNumberComparer (XmlSortOrder orderSort)
{
_nMulSort = (orderSort == XmlSortOrder.Ascending) ? 1 : -1;
}
public void Add(object expr, XmlSortOrder orderSort, XmlCaseOrder orderCase, string lang, XmlDataType dataType)
{
this._rgSorters.Add(new XPathSorter(expr, orderSort, orderCase, lang, dataType));
}
public override void AddSort(Object expr, XmlSortOrder order,
XmlCaseOrder caseOrder,
String lang, XmlDataType dataType){}
public OrderModifier (XmlSortOrder order, XmlSortOrder emptyOrder, string collation)
{
this.sortOrder = sortOrder;
this.emptyOrder = emptyOrder;
if (collation != null)
this.coll = new CultureInfo (collation);
}
internal XPathComparerHelper(
XmlSortOrder order,
XmlCaseOrder caseOrder,
CultureInfo cinfo,
XmlDataType dataType) {
_order = order;
_caseOrder = caseOrder;
_cinfo = cinfo;
_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,
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 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 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)
{
_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 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;
}
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);
}
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));
}
/// <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 XPathNumberComparer(XmlSortOrder orderSort)
{
this._nMulSort = ((orderSort != XmlSortOrder.Ascending) ? -1 : 1);
}
/// <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)
{
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);
}
}
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);
}
}
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);
}
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)
{
_rgSorters.Add (new XPathSorter (expr, orderSort, orderCase, lang, dataType));
}
public override void AddSort(object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType)
{
AddSort(expr, new XPathComparerHelper(order, caseOrder, lang, dataType));
}
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);
}
