protected override Expression VisitExtensionExpression(ExtensionExpression expression)
#endif
{
if (expression is SelectIdentifierVariableNameExpression)
{
var siv = expression as SelectIdentifierVariableNameExpression;
var v = _values[siv.Name].ToString();
if (!String.IsNullOrEmpty(siv.IdentifierPrefix) && v.StartsWith(siv.IdentifierPrefix))
{
v = v.Substring(siv.IdentifierPrefix.Length);
}
if (siv.Type.IsInstanceOfType(v))
{
return(Expression.Constant(v, siv.Type));
}
var converted = _converter(v, RdfDatatypes.GetLiteralLanguageTag(_values[siv.Name]), siv.Type);
return(Expression.Constant(converted, siv.Type));
}
if (expression is SelectVariableNameExpression)
{
var svn = expression as SelectVariableNameExpression;
var v = _values[svn.Name];
if (svn.Type.IsInstanceOfType(v))
{
return(Expression.Constant(v, svn.Type));
}
var converted = _converter(v.ToString(), RdfDatatypes.GetLiteralLanguageTag(v), svn.Type);
return(Expression.Constant(converted, svn.Type));
}
return(expression);
}
/// <summary>
/// Sets the property of this object to the specified value
/// </summary>
/// <param name="type">The type of the property to set</param>
/// <param name="value">The new value of the property</param>
/// <param name="langCode">OPTIONAL : the language code for the new literal. This parameter is ignored if <paramref name="value"/> is an <see cref="IDataObject"/></param>
/// <returns>This IDataObject to allow chained calls</returns>
/// <remarks>This method will remove all existing properties of type <paramref name="type"/> from this data object
/// and add a single replacement property of the same type with <paramref name="value"/> as the property value.</remarks>
public IDataObject SetProperty(IDataObject type, object value, string langCode = null)
{
if (value is IDataObject)
{
return(SetRelatedObject(type, value as IDataObject));
}
if (value is ILiteralNode)
{
var lit = value as ILiteralNode;
SetPropertyLiteral(type, lit.Value, lit.DataType.ToString(), lit.Language);
return(this);
}
if (value is IUriNode)
{
var uri = value as IUriNode;
return(SetRelatedObject(type, _store.MakeDataObject(uri.Uri.ToString())));
}
if (value is Uri)
{
return(SetRelatedObject(type, _store.MakeDataObject(value.ToString())));
}
if (type == null)
{
throw new ArgumentNullException("type");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
string dataType = RdfDatatypes.GetRdfDatatype(value.GetType());
string litString = RdfDatatypes.GetLiteralString(value);
SetPropertyLiteral(type, litString, dataType, langCode);
return(this);
}
///<summary>
/// Removes any property on this data object with the specified type and value
///</summary>
///<param name="type">The type of the property to be removed</param>
///<param name="value">The value of the property to be removed</param>
///<param name="lang">OPTIONAL: The language code of the property to be removed. This parameter is ignored if <paramref name="value"/> is an <see cref="IDataObject"/></param>
///<returns>This IDataObject to allow chained calls</returns>
///<remarks>If this object has no matching property, then this call is a no-op</remarks>
public IDataObject RemoveProperty(IDataObject type, object value, string lang = null)
{
if (value is IDataObject)
{
RemoveDataObjectProperty(type, value as IDataObject);
}
else if (value is Uri)
{
RemoveDataObjectProperty(type, _store.MakeDataObject(value.ToString()));
}
else
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
string dataType = RdfDatatypes.GetRdfDatatype(value.GetType());
string litString = RdfDatatypes.GetLiteralString(value);
RemoveLiteralProperty(type, litString, dataType, lang);
}
return(this);
}
public void TestNegativeIntegerParsing()
{
const int v = -123456789;
var bsParsed = (int)RdfDatatypes.ParseLiteralString("-123456789", RdfDatatypes.NegativeInteger, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestDateTimeRoundtrip()
{
var v = new DateTime(2012, 03, 04, 09, 10, 11, 25, DateTimeKind.Utc);
var bsString = RdfDatatypes.GetLiteralString(v);
var parsed = RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.DateTime, null);
Assert.That(parsed, Is.EqualTo(v));
}
public void TestDoubleRoundtrip()
{
const double dbl = 1.123456789D;
var bsString = RdfDatatypes.GetLiteralString(dbl);
var bsParsed = (double)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Double, null);
Assert.That(bsParsed, Is.EqualTo(dbl));
}
public void TestIntegerRoundtrip()
{
const int v = -123456789;
var bsString = RdfDatatypes.GetLiteralString(v);
var bsParsed = (int)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Integer, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestUnsignedByteRoundtrip()
{
const byte v = 244;
var bsString = RdfDatatypes.GetLiteralString(v);
var bsParsed = (byte)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.UnsignedByte, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestStandardDoubleParsing()
{
var dbl = 1.123456789;
var literalIn = dbl.ToString(CultureInfo.InvariantCulture);
var dblOut = (double)RdfDatatypes.ParseLiteralString(literalIn, RdfDatatypes.Double, null);
Assert.That(dblOut, Is.EqualTo(dbl));
}
public void TestByteRoundtrip()
{
const sbyte v = -64;
var bsString = RdfDatatypes.GetLiteralString(v);
var bsParsed = (sbyte)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Byte, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestUnsignedLongRoundtrip()
{
const ulong v = 9876543210L;
var bsString = RdfDatatypes.GetLiteralString(v);
var bsParsed = (ulong)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.UnsignedLong, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestUnsignedShortRoundtrip()
{
const ushort v = 64000;
var bsString = RdfDatatypes.GetLiteralString(v);
var bsParsed = (ushort)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.UnsignedShort, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestDecimalRoundtrip()
{
const decimal d = 1.123456789M;
var bsString = RdfDatatypes.GetLiteralString(d);
var bsParsed = (decimal)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Decimal, null);
Assert.That(bsParsed, Is.EqualTo(d));
}
public void TestShortRoundtrip()
{
const short v = -16384;
var bsString = RdfDatatypes.GetLiteralString(v);
var bsParsed = (short)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Short, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestBooleanRoundtrip()
{
var bsString = RdfDatatypes.GetLiteralString(true);
Assert.That(RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Boolean, null), Is.True);
bsString = RdfDatatypes.GetLiteralString(false);
Assert.That(RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Boolean, null), Is.False);
}
public void TestLongRoundtrip()
{
const long v = -9876543210;
var bsString = RdfDatatypes.GetLiteralString(v);
var bsParsed = (long)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Long, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestFloatRoundtrip()
{
const float v = 1.12345F;
var bsString = RdfDatatypes.GetLiteralString(v);
var bsParsed = (float)RdfDatatypes.ParseLiteralString(bsString, RdfDatatypes.Float, null);
Assert.That(bsParsed, Is.EqualTo(v));
}
public void TestParseStringDerivatives()
{
const string v = "HelloWorld";
var p = RdfDatatypes.ParseLiteralString(v, RdfDatatypes.NormalizedString, null);
Assert.That(p, Is.EqualTo(v));
p = RdfDatatypes.ParseLiteralString(v, RdfDatatypes.Token, null);
Assert.That(p, Is.EqualTo(v));
p = RdfDatatypes.ParseLiteralString(v, RdfDatatypes.Language, null);
Assert.That(p, Is.EqualTo(v));
}
/// <summary>
/// Maps the xsd data type to a .NET type for literal values or creates / looks up a DataObject for
/// resources. BNodes get mapped to DataObjects.
/// </summary>
/// <param name="triple"></param>
/// <returns></returns>
private object CreateTypedObject(Triple triple)
{
if (triple.IsLiteral)
{
object retValue;
if (RdfDatatypes.TryParseLiteralString(triple.Object, triple.DataType, triple.LangCode, out retValue))
{
return(retValue);
}
return(triple.Object);
}
return(_store.MakeDataObject(triple.Object));
}
private static object GetTypedValue(XElement binding)
{
if (binding.Elements(SparqlResultsNamespace + "literal").FirstOrDefault() != null)
{
var datatype = GetBindingDataType(binding) ?? Constants.DefaultDatatypeUri;
object parsedValue;
if (RdfDatatypes.TryParseLiteralString(binding.Value, datatype, out parsedValue))
{
return(parsedValue);
}
return(binding.Value);
}
return(new Uri(binding.Value));
}
protected override Expression VisitMemberExpression(MemberExpression expression)
{
if (expression.Expression is SelectVariableNameExpression)
{
// Extracting a value from a resource that should be in the _values dictionary
var svn = expression.Expression as SelectVariableNameExpression;
var parent = _converter(_values[svn.Name].ToString(), RdfDatatypes.GetLiteralLanguageTag(_values[svn.Name]), svn.Type);
if (expression.Member is PropertyInfo)
{
var property = expression.Member as PropertyInfo;
var value = property.GetValue(parent, null);
return(Expression.Constant(value));
}
}
return(base.VisitMemberExpression(expression));
}
/// <summary>
/// Sets the property of this object to the specified value
/// </summary>
/// <param name="type">The type of the property to set</param>
/// <param name="value">The new value of the property</param>
/// <param name="langCode">OPTIONAL : the language code for the new literal. This parameter is ignored if <paramref name="value"/> is an <see cref="IDataObject"/></param>
/// <returns>This IDataObject to allow chained calls</returns>
/// <remarks>This method will remove all existing properties of type <paramref name="type"/> from this data object
/// and add a single replacement property of the same type with <paramref name="value"/> as the property value.</remarks>
public IDataObject SetProperty(IDataObject type, object value, string langCode = null)
{
if (value is IDataObject)
{
return(SetRelatedObject(type, value as IDataObject));
}
if (type == null)
{
throw new ArgumentNullException("type");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
string dataType = RdfDatatypes.GetRdfDatatype(value.GetType());
string litString = RdfDatatypes.GetLiteralString(value);
SetPropertyLiteral(type, litString, dataType, langCode);
return(this);
}
/// <summary>
/// Converts a value.
/// </summary>
/// <returns>
/// A converted value. If the method returns null, the valid null value is used.
/// </returns>
/// <param name="value">The value produced by the binding source.</param><param name="targetType">The type of the binding target property.</param><param name="parameter">The converter parameter to use.</param><param name="culture">The culture to use in the converter.</param>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var resultElement = value as XElement;
if (resultElement != null)
{
var colName = parameter as string;
var bindingElement =
resultElement.Elements(SparqlResultsNs + "binding").Where(
el => el.Attribute("name") != null && el.Attribute("name").Value.Equals(colName))
.Select(el => el.Elements().FirstOrDefault())
.FirstOrDefault();
if (bindingElement != null)
{
if (bindingElement.Name.LocalName == "uri")
{
return(String.Format("<{0}>", bindingElement.Value));
}
if (bindingElement.Name.LocalName == "literal")
{
if (bindingElement.Attribute("datatype") != null)
{
var datatype = bindingElement.Attribute("datatype").Value;
var langAttr = bindingElement.Attribute(XNamespace.Xml + "lang");
var lang = langAttr == null ? String.Empty : langAttr.Value;
try
{
return(RdfDatatypes.ParseLiteralString(bindingElement.Value, datatype, lang));
}
catch (Exception)
{
// Ignore and fall through to return the string value
}
}
return(bindingElement.Value);
}
}
}
return(String.Empty);
}
/// <summary>
/// Adds a new property value to this object
/// </summary>
/// <param name="type">The type of the property to add</param>
/// <param name="value">The value of the property</param>
/// <param name="lang">OPTIONAL: The language code of the literal value. This parameter is ignored if <paramref name="value"/> is an <see cref="IDataObject"/></param>
/// <returns>This IDataOjbect to allow chained calls</returns>
public IDataObject AddProperty(IDataObject type, object value, string lang = null)
{
if (value is IDataObject)
{
AddDataObjectProperty(type, value as IDataObject);
}
else
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
string dataType = RdfDatatypes.GetRdfDatatype(value.GetType());
string litString = RdfDatatypes.GetLiteralString(value);
AddLiteralProperty(type, litString, dataType, lang);
}
return(this);
}
/// <summary>
/// Return the RDF datatype to apply to literals of the specified system type.
/// </summary>
/// <param name="systemType">The System.Type of the literal value</param>
/// <returns>The RDF datatype to apply</returns>
public override string GetDatatype(Type systemType)
{
return(RdfDatatypes.GetRdfDatatype(systemType));
}
