/// <summary>
/// Distinct-values operation.
/// </summary>
/// <param name="args">
/// Result from the expressions evaluation. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of fn:distinct-values operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence distinct_values(java.util.Collection args, org.eclipse.wst.xml.xpath2.api.DynamicContext context) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
public static ResultSequence distinct_values(ICollection args, DynamicContext context)
{
ResultBuffer rs = new ResultBuffer();
// get args
IEnumerator citer = args.GetEnumerator();
citer.MoveNext();
ResultSequence arg1 = (ResultSequence)citer.Current;
ResultSequence arg2 = ResultBuffer.EMPTY;
if (citer.MoveNext())
{
arg2 = (ResultSequence)citer.Current;
}
string collationURI = context.CollationProvider.DefaultCollation;
if (!(arg2 == null || arg2.empty()))
{
XSString collation = (XSString)arg2.item(0);
collationURI = collation.StringValue;
}
for (var iter = arg1.iterator(); iter.MoveNext();)
{
AnyAtomicType atomizedItem = (AnyAtomicType)FnData.atomize((Item)iter.Current);
if (!contains(rs, atomizedItem, context, collationURI))
{
rs.add(atomizedItem);
}
}
return(rs.Sequence);
}
/// <summary>
/// Converts arguments to values.
/// </summary>
/// <param name="args">
/// Result from expressions evaluation. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of conversion. </returns>
private static ICollection value_convert_args(ICollection args)
{
var result = new ArrayList(args.Count);
// atomize arguments
for (IEnumerator i = args.GetEnumerator(); i.MoveNext();)
{
ResultSequence rs = (ResultSequence)i.Current;
//FnData.fast_atomize(rs);
rs = FnData.atomize(rs);
if (rs.empty())
{
return(new ArrayList());
}
if (rs.size() > 1)
{
throw new DynamicError(TypeError.invalid_type(null));
}
Item arg = rs.first();
if (arg is XSUntypedAtomic)
{
arg = new XSString(arg.StringValue);
}
result.Add(arg);
}
return(result);
}
/// <summary>
/// A fast Equality operation, no conversion for the inputs performed.
/// </summary>
/// <param name="one">
/// input1 of any type. </param>
/// <param name="two">
/// input2 of any type. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of Equality operation. </returns>
public static bool fs_eq_fast(AnyType one, AnyType two, DynamicContext context)
{
one = FnData.atomize((Item)one);
two = FnData.atomize((Item)two);
if (one is XSUntypedAtomic)
{
one = new XSString(one.StringValue);
}
if (two is XSUntypedAtomic)
{
two = new XSString(two.StringValue);
}
if (!(one is CmpEq))
{
DynamicError.throw_type_error();
}
CmpEq cmpone = (CmpEq)one;
return(cmpone.eq(two, context));
}
/// <summary>
/// Obtain numeric value from expression.
/// </summary>
/// <param name="arg">
/// input expression. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Resulting numeric type from the operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.processor.internal.types.NumericType get_single_numeric_arg(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
public static NumericType get_single_numeric_arg(ResultSequence arg)
{
int size = arg.size();
if (size > 1)
{
DynamicError.throw_type_error();
}
if (size == 0)
{
return(null);
}
arg = FnData.atomize(arg);
AnyType at = (AnyType)arg.item(0);
if (!(at is NumericType))
{
throw DynamicError.invalidType();
}
return((NumericType)at);
}
/// <summary>
/// Convert and promote arguments for operation.
/// </summary>
/// <param name="args">
/// input arguments. </param>
/// <param name="sc"> </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of conversion. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private static java.util.Collection convert_args(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
private static ICollection convert_args(ICollection args)
{
var result = new ArrayList();
// Keep track of numeric types for promotion
bool has_float = false;
bool has_double = false;
// atomize arguments
for (IEnumerator i = args.GetEnumerator(); i.MoveNext();)
{
ResultSequence rs = FnData.atomize((ResultSequence)i.Current);
if (rs.empty())
{
return(new ArrayList());
}
if (rs.size() > 1)
{
throw new DynamicError(TypeError.invalid_type(null));
}
AnyType arg = (AnyType)rs.item(0);
if (arg is XSUntypedAtomic)
{
arg = new XSDouble(arg.StringValue);
}
if (arg is XSDouble)
{
has_double = true;
}
if (arg is XSFloat)
{
has_float = true;
}
result.Add(ResultBuffer.wrap(arg));
}
if (has_double)
{
has_float = false;
}
if (has_double || has_float)
{
var result2 = new ArrayList();
// promote arguments
for (IEnumerator i = result.GetEnumerator(); i.MoveNext();)
{
ResultSequence rs = (ResultSequence)i.Current;
Item arg = rs.item(0);
if (has_double && (arg is XSFloat))
{
arg = new XSDouble(((XSFloat)arg).float_value());
}
else if (has_double && (arg is XSDecimal))
{
arg = new XSDouble(((XSDecimal)arg).double_value());
}
else if (has_float && (arg is XSDecimal))
{
arg = new XSFloat((float)((XSDecimal)arg).double_value());
}
result2.Add(arg);
}
return(result2);
}
return(result);
}
// voodoo 3
/// <summary>
/// Actual equality operation for fs_eq_general.
/// </summary>
/// <param name="args">
/// input arguments. </param>
/// <param name="type">
/// type of the arguments. </param>
/// <param name="mname">
/// Method name for template simulation. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of the operation. </returns>
public static ResultSequence do_cmp_general_op(ICollection args, Type type, string mname, DynamicContext dc)
{
// do the voodoo
MethodBase comparator = null;
try
{
Type[] margsdef = new Type[] { type };
Type[] margsdef2 = new Type[] { typeof(ICollection), typeof(DynamicContext) };
object[] margs3 = new object[] { mname, margsdef2 };
var v1 = typeof(GenericIComparer)
.GetMethod("GetComparer");
var v2 = v1.MakeGenericMethod(margsdef);
comparator = (MethodBase)v2.Invoke(null, margs3);
}
catch
{
throw new Exception("Can't find method : " + mname);
}
// sanity check args and get them
if (args.Count != 2)
{
DynamicError.throw_type_error();
}
IEnumerator argiter = args.GetEnumerator();
argiter.MoveNext();
ResultSequence one = (ResultSequence)argiter.Current;
argiter.MoveNext();
ResultSequence two = (ResultSequence)argiter.Current;
// XXX ?
if (one.empty() || two.empty())
{
return(ResultSequenceFactory.create_new(new XSBoolean(false)));
}
// atomize
one = FnData.atomize(one);
two = FnData.atomize(two);
// we gotta find a pair that satisfied the condition
for (IEnumerator i = one.iterator(); i.MoveNext();)
{
AnyType a = (AnyType)i.Current;
for (IEnumerator j = two.iterator(); j.MoveNext();)
{
AnyType b = (AnyType)j.Current;
if (do_general_pair(a, b, comparator, dc))
{
return(ResultSequenceFactory.create_new(new XSBoolean(true)));
}
}
}
return(ResultSequenceFactory.create_new(new XSBoolean(false)));
}
// convert argument according to section 3.1.5 of xpath 2.0 spec
/// <summary>
/// Convert the input argument according to section 3.1.5 of specification.
/// </summary>
/// <param name="arg">
/// input argument. </param>
/// <param name="expected">
/// Expected Sequence type. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Converted argument. </returns>
public static org.eclipse.wst.xml.xpath2.api.ResultSequence convert_argument(org.eclipse.wst.xml.xpath2.api.ResultSequence arg, SeqType expected)
{
ResultBuffer result = new ResultBuffer();
// XXX: Should use type_class instead and use item.getClass().isAssignableTo(expected.type_class())
AnyType expected_type = expected.type();
// expected is atomic
if (expected_type is AnyAtomicType)
{
AnyAtomicType expected_aat = (AnyAtomicType)expected_type;
// atomize
org.eclipse.wst.xml.xpath2.api.ResultSequence rs = FnData.atomize(arg);
// cast untyped to expected type
for (var i = rs.iterator(); i.MoveNext();)
{
AnyType item = (AnyType)i.Current;
if (item is XSUntypedAtomic)
{
// create a new item of the expected
// type initialized with from the string
// value of the item
ResultSequence converted = null;
if (expected_aat is XSString)
{
XSString strType = new XSString(item.StringValue);
converted = ResultSequenceFactory.create_new(strType);
}
else
{
converted = ResultSequenceFactory.create_new(item);
}
result.concat(converted);
}
// xs:anyURI promotion to xs:string
else if (item is XSAnyURI && expected_aat is XSString)
{
result.add(new XSString(item.StringValue));
}
// numeric type promotion
else if (item is NumericType)
{
if (expected_aat is XSDouble)
{
XSDouble doubleType = new XSDouble(item.StringValue);
result.add(doubleType);
}
else
{
result.add(item);
}
}
else
{
result.add(item);
}
}
// do sequence type matching on converted arguments
return(expected.match(result.Sequence));
}
else
{
// do sequence type matching on converted arguments
return(expected.match(arg));
}
}
/// <summary>
/// Number operation.
/// </summary>
/// <param name="arg">
/// Result from the expressions evaluation. </param>
/// <param name="dc">
/// Result of dynamic context operation. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of fn:number operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.processor.internal.types.XSDouble fn_number(org.eclipse.wst.xml.xpath2.api.ResultSequence arg, org.eclipse.wst.xml.xpath2.api.EvaluationContext ec) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
public static XSDouble fn_number(ResultSequence arg, EvaluationContext ec)
{
if (arg.size() > 1)
{
throw new DynamicError(TypeError.invalid_type("bad argument passed to fn:number()"));
}
else if (arg.size() == 1)
{
Item at = arg.first();
/*
* if (!(at instanceof AnyAtomicType))
* DynamicError.throw_type_error();
*/
if (at is AnyAtomicType)
{
if ((at is XSDouble))
{
return((XSDouble)at);
}
else if ((at is XSFloat))
{
float value = ((XSFloat)at).float_value();
if (float.IsNaN(value))
{
return(new XSDouble(double.NaN));
}
else if (value == float.NegativeInfinity)
{
return(new XSDouble(double.NegativeInfinity));
}
else if (value == float.PositiveInfinity)
{
return(new XSDouble(double.PositiveInfinity));
}
else
{
return(new XSDouble((double)value));
}
}
else
{
XSDouble d = XSDouble.parse_double(at.StringValue);
return(d != null ? d : new XSDouble(double.NaN));
}
}
else if (at is NodeType)
{
XSDouble d = XSDouble.parse_double((FnData.atomize(at)).StringValue);
return(d != null ? d : new XSDouble(double.NaN));
}
}
else
{
return(new XSDouble(double.NaN));
}
// unreach
return(null);
}
