// 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>
/// Convert-Operand operation.
/// </summary>
/// <param name="args">
/// Result from the expressions evaluation. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of fs: 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 convert_operand(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
public static ResultSequence convert_operand(ICollection args)
{
Debug.Assert(args.Count == 2);
IEnumerator iter = args.GetEnumerator();
iter.MoveNext();
ResultSequence actual = (ResultSequence)iter.Current;
iter.MoveNext();
ResultSequence expected = (ResultSequence)iter.Current;
if (expected == null || expected.size() != 1)
{
DynamicError.throw_type_error();
}
Item at = expected.first();
if (!(at is AnyAtomicType))
{
DynamicError.throw_type_error();
}
AnyAtomicType exp_aat = (AnyAtomicType)at;
ResultBuffer result = new ResultBuffer();
// 1
if (actual.empty())
{
return(result.Sequence);
}
// convert sequence
for (var i = actual.iterator(); i.MoveNext();)
{
AnyType item = (AnyType)i.Current;
// 2
if (item is XSUntypedAtomic)
{
// a
if (exp_aat is XSUntypedAtomic)
{
result.add(new XSString(item.StringValue));
}
// b
else if (exp_aat is NumericType)
{
result.add(new XSDouble(item.StringValue));
}
// c
else
{
Debug.Assert(exp_aat is CtrType);
CtrType cons = (CtrType)exp_aat;
result.concat(cons.constructor(new XSString(item.StringValue)));
}
}
// 4
else
{
result.add(item);
}
}
return(result.Sequence);
}
/// <summary>
/// Insert-Before operation.
/// </summary>
/// <param name="args">
/// Result from the expressions evaluation. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of fn:insert-before 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 insert_before(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
public static ResultSequence insert_before(ICollection args)
{
Debug.Assert(args.Count == 3);
ResultBuffer rs = new ResultBuffer();
// get args
IEnumerator citer = args.GetEnumerator();
citer.MoveNext();
ResultSequence target = (ResultSequence)citer.Current;
citer.MoveNext();
ResultSequence arg2 = (ResultSequence)citer.Current;
citer.MoveNext();
ResultSequence inserts = (ResultSequence)citer.Current;
// sanity chex
if (arg2.size() != 1)
{
DynamicError.throw_type_error();
}
Item at = arg2.first();
if (!(at is XSInteger))
{
DynamicError.throw_type_error();
}
// XXX cloning!
if (target.empty())
{
return(inserts);
}
if (inserts.empty())
{
return(target);
}
int position = (int)((XSInteger)at).int_value();
if (position < 1)
{
position = 1;
}
int target_size = target.size();
if (position > target_size)
{
position = target_size + 1;
}
int curpos = 1;
for (var i = target.iterator(); i.MoveNext();)
{
at = (AnyType)i.Current;
if (curpos == position)
{
rs.concat(inserts);
}
rs.add(at);
curpos++;
}
if (curpos == position)
{
rs.concat(inserts);
}
return(rs.Sequence);
}
/// <summary>
/// Subsequence operation.
/// </summary>
/// <param name="args">
/// Result from the expressions evaluation. </param>
/// <exception cref="DynamicError">
/// Dynamic error. </exception>
/// <returns> Result of fn:subsequence 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 subsequence(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
public static ResultSequence subsequence(ICollection args)
{
ResultBuffer rs = new ResultBuffer();
// get args
IEnumerator citer = args.GetEnumerator();
citer.MoveNext();
ResultSequence seq = (ResultSequence)citer.Current;
if (seq.empty())
{
return(ResultBuffer.EMPTY);
}
citer.MoveNext();
ResultSequence startLoc = (ResultSequence)citer.Current;
ResultSequence length = null;
if (citer.MoveNext())
{
length = (ResultSequence)citer.Current;
}
Item at = startLoc.first();
if (!(at is NumericType))
{
DynamicError.throw_type_error();
}
at = new XSDouble(at.StringValue);
int start = (int)((XSDouble)at).double_value();
int effectiveNoItems = 0; // no of items beyond index >= 1 that are added to the result
if (length != null)
{
// the 3rd argument is present
if (length.size() != 1)
{
DynamicError.throw_type_error();
}
at = length.first();
if (!(at is NumericType))
{
DynamicError.throw_type_error();
}
at = new XSDouble(at.StringValue);
int len = (int)((XSDouble)at).double_value();
if (len < 0)
{
DynamicError.throw_type_error();
}
if (start <= 0)
{
effectiveNoItems = start + len - 1;
start = 1;
}
else
{
effectiveNoItems = len;
}
}
else
{
// 3rd argument is absent
if (start <= 0)
{
start = 1;
effectiveNoItems = seq.size();
}
else
{
effectiveNoItems = seq.size() - start + 1;
}
}
int pos = 1; // index running parallel to the iterator
int addedItems = 0;
if (effectiveNoItems > 0)
{
for (var seqIter = seq.iterator(); seqIter.MoveNext();)
{
at = (AnyType)seqIter.Current;
if (start <= pos && addedItems < effectiveNoItems)
{
rs.add(at);
addedItems++;
}
pos++;
}
}
return(rs.Sequence);
}
