/// <summary>
        /// Tries to create an XPath Function expression if the function Uri correseponds to a supported XPath Function
        /// </summary>
        /// <param name="u">Function Uri</param>
        /// <param name="args">Function Arguments</param>
        /// <param name="scalarArgs">Scalar Arguments</param>
        /// <param name="expr">Generated Expression</param>
        /// <returns>Whether an expression was successfully generated</returns>
        public bool TryCreateExpression(Uri u, List<ISparqlExpression> args, Dictionary<String,ISparqlExpression> scalarArgs, out ISparqlExpression expr)
        {
            //If any Scalar Arguments are present then can't possibly be an XPath Function
            if (scalarArgs.Count > 0)
            {
                expr = null;
                return false;
            }

            String func = u.ToString();
            if (func.StartsWith(XPathFunctionFactory.XPathFunctionsNamespace))
            {
                func = func.Substring(XPathFunctionFactory.XPathFunctionsNamespace.Length);
                ISparqlExpression xpathFunc = null;

                switch (func)
                {
                    case XPathFunctionFactory.Absolute:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathAbsoluteFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath abs() function");
                        }
                        break;
                    case XPathFunctionFactory.AdjustDateTimeToTimezone:
                        throw new NotSupportedException("XPath adjust-dateTime-to-timezone() function is not supported");
                    case XPathFunctionFactory.Boolean:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathBooleanFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath boolean() function");
                        }
                        throw new NotSupportedException("XPath boolean() function is not supported");
                    case XPathFunctionFactory.Ceiling:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathCeilingFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath ceiling() function");
                        }
                        break;
                    case XPathFunctionFactory.Compare:
                        if (args.Count == 2)
                        {
                            xpathFunc = new XPathCompareFunction(args.First(), args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath compare() function");
                        }
                        break;
                    case XPathFunctionFactory.Concat:
                        if (args.Count == 2)
                        {
                            xpathFunc = new XPathConcatFunction(args.First(), args.Last());
                        }
                        else if (args.Count > 2)
                        {
                            xpathFunc = new XPathConcatFunction(args);
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath concat() function");
                        }
                        break;
                    case XPathFunctionFactory.Contains:
                        if (args.Count == 2)
                        {
                            xpathFunc = new XPathContainsFunction(args.First(), args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath contains() function");
                        }
                        break;
                    case XPathFunctionFactory.DayFromDateTime:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathDayFromDateTimeFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath day-from-dateTime() function");
                        }
                        break;
                    case XPathFunctionFactory.EncodeForURI:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathEncodeForUriFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath encode-for-uri() function");
                        }
                        break;
                    case XPathFunctionFactory.EndsWith:
                        if (args.Count == 2)
                        {
                            xpathFunc = new XPathEndsWithFunction(args.First(), args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath ends-with() function");
                        }
                        break;
#if !NO_WEB
                    case XPathFunctionFactory.EscapeHtmlURI:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathEscapeHtmlUriFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath escape-html-uri() function");
                        }
                        break;
#endif
                    case XPathFunctionFactory.False:
                        if (args.Count == 0)
                        {
                            xpathFunc = new BooleanExpressionTerm(false);
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath false() function");
                        }
                        break;
                    case XPathFunctionFactory.Floor:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathFloorFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath floor() function");
                        }
                        break;
                    case XPathFunctionFactory.HoursFromDateTime:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathHoursFromDateTimeFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath hours-from-dateTime() function");
                        }
                        break;
                    case XPathFunctionFactory.LowerCase:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathLowerCaseFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath lower-case() function");
                        }
                        break;
                    case XPathFunctionFactory.Matches:
                        if (args.Count == 2)
                        {
                            xpathFunc = new RegexFunction(args.First(), args.Last());
                        }
                        else if (args.Count == 3)
                        {
                            xpathFunc = new RegexFunction(args.First(), args[1], args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath matches() function");
                        }
                        break;
                    case XPathFunctionFactory.MinutesFromDateTime:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathMinutesFromDateTimeFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath minutes-from-dateTime() function");
                        }
                        break;
                    case XPathFunctionFactory.MonthFromDateTime:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathMonthFromDateTimeFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath month-from-dateTime() function");
                        }
                        break;
                    case XPathFunctionFactory.NormalizeSpace:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathNormalizeSpaceFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
                        }
                        break;
#if !NO_NORM
                    case XPathFunctionFactory.NormalizeUnicode:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathNormalizeUnicodeFunction(args.First());
                        }
                        else if (args.Count == 2)
                        {
                            xpathFunc = new XPathNormalizeUnicodeFunction(args.First(), args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
                        } 
                        break;
#endif
                    case XPathFunctionFactory.Not:
                        if (args.Count == 1)
                        {
                            xpathFunc = new NegationExpression(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath not() function");
                        }
                        break;
                    case XPathFunctionFactory.Replace:
                        if (args.Count == 3)
                        {
                            xpathFunc = new XPathReplaceFunction(args.First(), args[1], args.Last());
                        }
                        else if (args.Count == 4)
                        {
                            xpathFunc = new XPathReplaceFunction(args.First(), args[1], args[2], args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath replace() function");
                        }
                        break;
                    case XPathFunctionFactory.Round:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathRoundFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath round() function");
                        }
                        break;
#if !SILVERLIGHT
                    case XPathFunctionFactory.RoundHalfToEven:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathRoundHalfToEvenFunction(args.First());
                        }
                        else if (args.Count == 2)
                        {
                            xpathFunc = new XPathRoundHalfToEvenFunction(args.First(), args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath round-half-to-even() function");
                        }
                        break;
#endif
                    case XPathFunctionFactory.SecondsFromDateTime:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathSecondsFromDateTimeFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath seconds-from-dateTime() function");
                        }
                        break;
                    case XPathFunctionFactory.StartsWith:
                        if (args.Count == 2)
                        {
                            xpathFunc = new XPathStartsWithFunction(args.First(), args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath starts-with() function");
                        }
                        break;
                    case XPathFunctionFactory.StringJoin:
                        if (args.Count == 1)
                        {
                            xpathFunc = new NonNumericAggregateExpressionTerm(new XPathStringJoinFunction(args.First()));
                        }
                        else if (args.Count == 2)
                        {
                            xpathFunc = new NonNumericAggregateExpressionTerm(new XPathStringJoinFunction(args.First(), args.Last()));
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath string-join() function");
                        }
                        break;
                    case XPathFunctionFactory.StringLength:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathStringLengthFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath string-length() function");
                        }
                        break;
                    case XPathFunctionFactory.Substring:
                        if (args.Count == 2)
                        {
                            xpathFunc = new XPathSubstringFunction(args.First(), args.Last());
                        }
                        else if (args.Count == 3)
                        {
                            xpathFunc = new XPathSubstringFunction(args.First(), args[1], args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath substring() function");
                        }
                        break;
                    case XPathFunctionFactory.SubstringAfter:
                        if (args.Count == 2)
                        {
                            xpathFunc = new XPathSubstringAfterFunction(args.First(), args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath substring-after() function");
                        }
                        break;
                    case XPathFunctionFactory.SubstringBefore:
                        if (args.Count == 2)
                        {
                            xpathFunc = new XPathSubstringBeforeFunction(args.First(), args.Last());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath substring-before() function");
                        }
                        break;
                    case XPathFunctionFactory.TimezoneFromDateTime:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathTimezoneFromDateTimeFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath timezone-from-dateTime() function");
                        }
                        break;
                    case XPathFunctionFactory.Translate:
                        throw new NotSupportedException("XPath translate() function is not supported");
                    case XPathFunctionFactory.True:
                        if (args.Count == 0)
                        {
                            xpathFunc = new BooleanExpressionTerm(true);
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath true() function");
                        }
                        break;
                    case XPathFunctionFactory.UpperCase:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathUpperCaseFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath upper-case() function");
                        }
                        break;
                    case XPathFunctionFactory.YearFromDateTime:
                        if (args.Count == 1)
                        {
                            xpathFunc = new XPathYearFromDateTimeFunction(args.First());
                        }
                        else
                        {
                            throw new RdfParseException("Incorrect number of arguments for the XPath year-from-dateTime() function");
                        }
                        break;
                }

                if (xpathFunc != null)
                {
                    expr = xpathFunc;
                    return true;
                }
            }
            expr = null;
            return false;        
        }
Exemplo n.º 2
0
        /// <summary>
        /// Tries to create an XPath Function expression if the function Uri correseponds to a supported XPath Function
        /// </summary>
        /// <param name="u">Function Uri</param>
        /// <param name="args">Function Arguments</param>
        /// <param name="scalarArgs">Scalar Arguments</param>
        /// <param name="expr">Generated Expression</param>
        /// <returns>Whether an expression was successfully generated</returns>
        public bool TryCreateExpression(Uri u, List <ISparqlExpression> args, Dictionary <String, ISparqlExpression> scalarArgs, out ISparqlExpression expr)
        {
            //If any Scalar Arguments are present then can't possibly be an XPath Function
            if (scalarArgs.Count > 0)
            {
                expr = null;
                return(false);
            }

            String func = u.ToString();

            if (func.StartsWith(XPathFunctionFactory.XPathFunctionsNamespace))
            {
                func = func.Substring(XPathFunctionFactory.XPathFunctionsNamespace.Length);
                ISparqlExpression xpathFunc = null;

                switch (func)
                {
                case XPathFunctionFactory.Absolute:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathAbsoluteFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath abs() function");
                    }
                    break;

                case XPathFunctionFactory.AdjustDateTimeToTimezone:
                    throw new NotSupportedException("XPath adjust-dateTime-to-timezone() function is not supported");

                case XPathFunctionFactory.Boolean:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathBooleanFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath boolean() function");
                    }
                    throw new NotSupportedException("XPath boolean() function is not supported");

                case XPathFunctionFactory.Ceiling:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathCeilingFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath ceiling() function");
                    }
                    break;

                case XPathFunctionFactory.Compare:
                    if (args.Count == 2)
                    {
                        xpathFunc = new XPathCompareFunction(args.First(), args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath compare() function");
                    }
                    break;

                case XPathFunctionFactory.Concat:
                    if (args.Count == 2)
                    {
                        xpathFunc = new XPathConcatFunction(args.First(), args.Last());
                    }
                    else if (args.Count > 2)
                    {
                        xpathFunc = new XPathConcatFunction(args);
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath concat() function");
                    }
                    break;

                case XPathFunctionFactory.Contains:
                    if (args.Count == 2)
                    {
                        xpathFunc = new XPathContainsFunction(args.First(), args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath contains() function");
                    }
                    break;

                case XPathFunctionFactory.DayFromDateTime:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathDayFromDateTimeFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath day-from-dateTime() function");
                    }
                    break;

                case XPathFunctionFactory.EncodeForURI:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathEncodeForUriFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath encode-for-uri() function");
                    }
                    break;

                case XPathFunctionFactory.EndsWith:
                    if (args.Count == 2)
                    {
                        xpathFunc = new XPathEndsWithFunction(args.First(), args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath ends-with() function");
                    }
                    break;

#if !NO_WEB
                case XPathFunctionFactory.EscapeHtmlURI:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathEscapeHtmlUriFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath escape-html-uri() function");
                    }
                    break;
#endif
                case XPathFunctionFactory.False:
                    if (args.Count == 0)
                    {
                        xpathFunc = new BooleanExpressionTerm(false);
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath false() function");
                    }
                    break;

                case XPathFunctionFactory.Floor:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathFloorFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath floor() function");
                    }
                    break;

                case XPathFunctionFactory.HoursFromDateTime:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathHoursFromDateTimeFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath hours-from-dateTime() function");
                    }
                    break;

                case XPathFunctionFactory.LowerCase:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathLowerCaseFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath lower-case() function");
                    }
                    break;

                case XPathFunctionFactory.Matches:
                    if (args.Count == 2)
                    {
                        xpathFunc = new RegexFunction(args.First(), args.Last());
                    }
                    else if (args.Count == 3)
                    {
                        xpathFunc = new RegexFunction(args.First(), args[1], args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath matches() function");
                    }
                    break;

                case XPathFunctionFactory.MinutesFromDateTime:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathMinutesFromDateTimeFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath minutes-from-dateTime() function");
                    }
                    break;

                case XPathFunctionFactory.MonthFromDateTime:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathMonthFromDateTimeFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath month-from-dateTime() function");
                    }
                    break;

                case XPathFunctionFactory.NormalizeSpace:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathNormalizeSpaceFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
                    }
                    break;

#if !NO_NORM
                case XPathFunctionFactory.NormalizeUnicode:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathNormalizeUnicodeFunction(args.First());
                    }
                    else if (args.Count == 2)
                    {
                        xpathFunc = new XPathNormalizeUnicodeFunction(args.First(), args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
                    }
                    break;
#endif
                case XPathFunctionFactory.Not:
                    if (args.Count == 1)
                    {
                        xpathFunc = new NegationExpression(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath not() function");
                    }
                    break;

                case XPathFunctionFactory.Replace:
                    if (args.Count == 3)
                    {
                        xpathFunc = new XPathReplaceFunction(args.First(), args[1], args.Last());
                    }
                    else if (args.Count == 4)
                    {
                        xpathFunc = new XPathReplaceFunction(args.First(), args[1], args[2], args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath replace() function");
                    }
                    break;

                case XPathFunctionFactory.Round:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathRoundFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath round() function");
                    }
                    break;

#if !SILVERLIGHT
                case XPathFunctionFactory.RoundHalfToEven:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathRoundHalfToEvenFunction(args.First());
                    }
                    else if (args.Count == 2)
                    {
                        xpathFunc = new XPathRoundHalfToEvenFunction(args.First(), args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath round-half-to-even() function");
                    }
                    break;
#endif
                case XPathFunctionFactory.SecondsFromDateTime:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathSecondsFromDateTimeFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath seconds-from-dateTime() function");
                    }
                    break;

                case XPathFunctionFactory.StartsWith:
                    if (args.Count == 2)
                    {
                        xpathFunc = new XPathStartsWithFunction(args.First(), args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath starts-with() function");
                    }
                    break;

                case XPathFunctionFactory.StringJoin:
                    if (args.Count == 1)
                    {
                        xpathFunc = new NonNumericAggregateExpressionTerm(new XPathStringJoinFunction(args.First()));
                    }
                    else if (args.Count == 2)
                    {
                        xpathFunc = new NonNumericAggregateExpressionTerm(new XPathStringJoinFunction(args.First(), args.Last()));
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath string-join() function");
                    }
                    break;

                case XPathFunctionFactory.StringLength:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathStringLengthFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath string-length() function");
                    }
                    break;

                case XPathFunctionFactory.Substring:
                    if (args.Count == 2)
                    {
                        xpathFunc = new XPathSubstringFunction(args.First(), args.Last());
                    }
                    else if (args.Count == 3)
                    {
                        xpathFunc = new XPathSubstringFunction(args.First(), args[1], args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath substring() function");
                    }
                    break;

                case XPathFunctionFactory.SubstringAfter:
                    if (args.Count == 2)
                    {
                        xpathFunc = new XPathSubstringAfterFunction(args.First(), args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath substring-after() function");
                    }
                    break;

                case XPathFunctionFactory.SubstringBefore:
                    if (args.Count == 2)
                    {
                        xpathFunc = new XPathSubstringBeforeFunction(args.First(), args.Last());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath substring-before() function");
                    }
                    break;

                case XPathFunctionFactory.TimezoneFromDateTime:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathTimezoneFromDateTimeFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath timezone-from-dateTime() function");
                    }
                    break;

                case XPathFunctionFactory.Translate:
                    throw new NotSupportedException("XPath translate() function is not supported");

                case XPathFunctionFactory.True:
                    if (args.Count == 0)
                    {
                        xpathFunc = new BooleanExpressionTerm(true);
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath true() function");
                    }
                    break;

                case XPathFunctionFactory.UpperCase:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathUpperCaseFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath upper-case() function");
                    }
                    break;

                case XPathFunctionFactory.YearFromDateTime:
                    if (args.Count == 1)
                    {
                        xpathFunc = new XPathYearFromDateTimeFunction(args.First());
                    }
                    else
                    {
                        throw new RdfParseException("Incorrect number of arguments for the XPath year-from-dateTime() function");
                    }
                    break;
                }

                if (xpathFunc != null)
                {
                    expr = xpathFunc;
                    return(true);
                }
            }
            expr = null;
            return(false);
        }