/// <summary>
/// Tries to remove formatting specific to this parser's expected type.
/// </summary>
/// <param name="text">The text to remove formatting from.</param>
/// <returns>Whether or not the expected formatting was found and succesfully removed.</returns>
internal virtual bool TryRemoveFormatting(ref string text)
{
if (this.prefix != null)
{
if (!UriPrimitiveTypeParser.TryRemovePrefix(this.prefix, ref text))
{
return(false);
}
}
bool shouldBeQuoted = this.prefix != null || ValueOfTypeCanContainQuotes(this.expectedType);
if (shouldBeQuoted && !UriPrimitiveTypeParser.TryRemoveQuotes(ref text))
{
return(false);
}
if (this.suffix != null)
{
// we need to try to remove the literal even if it isn't required.
if (!TryRemoveLiteralSuffix(this.suffix, ref text) && this.suffixRequired)
{
return(false);
}
}
return(true);
}
internal static bool TryBindIdentifier(string identifier, IEdmEnumTypeReference typeReference, IEdmModel modelWhenNoTypeReference, out QueryNode boundEnum)
{
boundEnum = null;
string text = identifier;
// parse the string, e.g., NS.Color'Green'
// get type information, and also convert Green into an ODataEnumValue
// find the first ', before that, it is namespace.type
int indexOfSingleQuote = text.IndexOf('\'');
if (indexOfSingleQuote < 0)
{
return(false);
}
string namespaceAndType = text.Substring(0, indexOfSingleQuote);
Debug.Assert((typeReference == null) || (modelWhenNoTypeReference == null), "((typeReference == null) || (modelWhenNoTypeReference == null)");
// validate typeReference but allow type name not found in model for delayed throwing.
if ((typeReference != null) && !string.Equals(namespaceAndType, typeReference.FullName()))
{
return(false);
}
// get the type
IEdmEnumType enumType = typeReference != null
?
(IEdmEnumType)typeReference.Definition
:
UriEdmHelpers.FindEnumTypeFromModel(modelWhenNoTypeReference, namespaceAndType);
if (enumType == null)
{
return(false);
}
// now, find out the value
UriPrimitiveTypeParser.TryRemovePrefix(namespaceAndType, ref text);
UriPrimitiveTypeParser.TryRemoveQuotes(ref text);
// parse string or int value to edm enum value
string enumValueString = text;
ODataEnumValue enumValue;
if (!TryParseEnum(enumType, enumValueString, out enumValue))
{
return(false);
}
// create an enum node, enclosing an odata enum value
IEdmEnumTypeReference enumTypeReference = typeReference ?? new EdmEnumTypeReference(enumType, false);
boundEnum = new ConstantNode(enumValue, identifier, enumTypeReference);
return(true);
}
/// <summary>
/// Tries to remove formatting specific to this parser's expected type.
/// </summary>
/// <param name="text">The text to remove formatting from.</param>
/// <returns>
/// Whether or not the expected formatting was found and succesfully removed.
/// </returns>
internal override bool TryRemoveFormatting(ref string text)
{
if (!UriPrimitiveTypeParser.TryRemovePrefix(ExpressionConstants.LiteralPrefixBinary, ref text))
{
return(false);
}
if (!UriPrimitiveTypeParser.TryRemoveQuotes(ref text))
{
return(false);
}
return(true);
}
internal static bool TryBindIdentifier(string identifier, IEdmModel model, out QueryNode boundEnum)
{
boundEnum = null;
string text = identifier;
// parse the string, e.g., NS.Color'Green'
// get type information, and also convert Green into an ODataEnumValue
// find the first ', before that, it is namespace.type
int indexOfSingleQuote = text.IndexOf('\'');
if (indexOfSingleQuote < 0)
{
return(false);
}
string namespaceAndType = text.Substring(0, indexOfSingleQuote);
// find the type from edm model
IEdmEnumType enumType = UriEdmHelpers.FindEnumTypeFromModel(model, namespaceAndType);
if (enumType == null)
{
return(false);
}
// now, find out the value
UriPrimitiveTypeParser.TryRemovePrefix(namespaceAndType, ref text);
UriPrimitiveTypeParser.TryRemoveQuotes(ref text);
// parse string or int value to edm enum value
string enumValueString = text;
ODataEnumValue enumValue;
enumType.TryParseEnum(enumValueString, out enumValue);
if (enumValue == null)
{
return(false);
}
// create an enum node, enclosing an odata enum value
EdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, false);
boundEnum = new ConstantNode(enumValue, identifier, enumTypeReference);
return(true);
}
/// <summary>
/// Try to parse a string value into a non-negative integer.
/// </summary>
/// <param name="text">The string value to parse.</param>
/// <param name="nonNegativeInteger">The non-negative integer value parsed from the <paramref name="text"/>.</param>
/// <returns>True if <paramref name="text"/> could successfully be parsed into a non-negative integer; otherwise returns false.</returns>
internal static bool TryUriStringToNonNegativeInteger(string text, out int nonNegativeInteger)
{
Debug.Assert(text != null, "text != null");
object valueAsObject;
if (!UriPrimitiveTypeParser.TryUriStringToPrimitive(text, EdmCoreModel.Instance.GetInt32(false), out valueAsObject))
{
nonNegativeInteger = -1;
return(false);
}
nonNegativeInteger = (int)valueAsObject;
if (nonNegativeInteger < 0)
{
return(false);
}
return(true);
}
/// <summary>
/// Parses typed literals.
/// </summary>
/// <param name="lexer">The lexer to use.</param>
/// <param name="targetTypeReference">Expected type to be parsed.</param>
/// <param name="targetTypeName">The EDM type name of the expected type to be parsed.</param>
/// <returns>The literal token produced by building the given literal.</returns>
private static LiteralToken ParseTypedLiteral(ExpressionLexer lexer, IEdmPrimitiveTypeReference targetTypeReference, string targetTypeName)
{
Debug.Assert(lexer != null, "lexer != null");
object targetValue;
string reason;
if (!UriPrimitiveTypeParser.TryUriStringToPrimitive(lexer.CurrentToken.Text, targetTypeReference, out targetValue, out reason))
{
string message;
if (reason == null)
{
message = ODataErrorStrings.UriQueryExpressionParser_UnrecognizedLiteral(
targetTypeName,
lexer.CurrentToken.Text,
lexer.CurrentToken.Position,
lexer.ExpressionText);
}
else
{
message = ODataErrorStrings.UriQueryExpressionParser_UnrecognizedLiteralWithReason(
targetTypeName,
lexer.CurrentToken.Text,
lexer.CurrentToken.Position,
lexer.ExpressionText,
reason);
}
throw ParseError(message);
}
LiteralToken result = new LiteralToken(targetValue, lexer.CurrentToken.Text);
lexer.NextToken();
return(result);
}
/// <summary>
/// Tries to remove formatting specific to this parser's expected type.
/// </summary>
/// <param name="text">The text to remove formatting from.</param>
/// <returns>
/// Whether or not the expected formatting was found and succesfully removed.
/// </returns>
internal override bool TryRemoveFormatting(ref string text)
{
return(UriPrimitiveTypeParser.TryRemoveQuotes(ref text));
}
