public void TestFixtureSetUp()
{
var datumConverterFactory = Substitute.For<IDatumConverterFactory>();
var stringDatum = new Datum() {
type = Datum.DatumType.R_STR,
r_str = "Jackpot!",
};
var stringDatumConverter = Substitute.For<IDatumConverter<string>>();
stringDatumConverter
.ConvertObject("Jackpot!")
.Returns(stringDatum);
stringDatumConverter
.ConvertDatum(Arg.Is<Datum>(d => d.type == stringDatum.type && d.r_str == stringDatum.r_str))
.Returns("Jackpot!");
testObject2Converter = DataContractDatumConverterFactory.Instance.Get<TestObject2>(datumConverterFactory);
testObject4Converter = DataContractDatumConverterFactory.Instance.Get<TestObject4>(datumConverterFactory);
testObjectStructEmitDefaultValueFieldConverter = DataContractDatumConverterFactory.Instance.Get<TestObjectStructEmitDefaultValueField>(datumConverterFactory);
testObjectStructEmitDefaultValuePropertyConverter = DataContractDatumConverterFactory.Instance.Get<TestObjectStructEmitDefaultValueProperty>(datumConverterFactory);
IDatumConverter<string> value;
datumConverterFactory
.TryGet<string>(datumConverterFactory, out value)
.Returns(args => {
args[1] = stringDatumConverter;
return true;
});
}
public void TestFixtureSetUp()
{
var datumConverterFactory = Substitute.For <IDatumConverterFactory>();
var stringDatum = new Datum()
{
type = Datum.DatumType.R_STR,
r_str = "Jackpot!",
};
var stringDatumConverter = Substitute.For <IDatumConverter <string> >();
stringDatumConverter
.ConvertObject("Jackpot!")
.Returns(stringDatum);
stringDatumConverter
.ConvertDatum(Arg.Is <Datum>(d => d.type == stringDatum.type && d.r_str == stringDatum.r_str))
.Returns("Jackpot!");
testObject2Converter = DataContractDatumConverterFactory.Instance.Get <TestObject2>(datumConverterFactory);
testObject4Converter = DataContractDatumConverterFactory.Instance.Get <TestObject4>(datumConverterFactory);
testObjectStructEmitDefaultValueFieldConverter = DataContractDatumConverterFactory.Instance.Get <TestObjectStructEmitDefaultValueField>(datumConverterFactory);
testObjectStructEmitDefaultValuePropertyConverter = DataContractDatumConverterFactory.Instance.Get <TestObjectStructEmitDefaultValueProperty>(datumConverterFactory);
IDatumConverter <string> value;
datumConverterFactory
.TryGet <string>(datumConverterFactory, out value)
.Returns(args => {
args[1] = stringDatumConverter;
return(true);
});
}
public override Dictionary <string, TValue> ConvertDatum(Spec.Datum datum)
{
if (datum.type == Spec.Datum.DatumType.R_NULL)
{
return(null);
}
if (datum.type != RethinkDb.Spec.Datum.DatumType.R_OBJECT)
{
throw new NotSupportedException("Attempted to convert Datum to named-value dictionary, but Datum was unsupported type " + datum.type);
}
Dictionary <string, TValue> retval = new Dictionary <string, TValue>();
IDatumConverter valueConverter = null;
if (typeof(TValue) != typeof(object))
{
valueConverter = rootDatumConverterFactory.Get <TValue>();
}
foreach (var kvp in datum.r_object)
{
IDatumConverter thisValueConverter = valueConverter;
if (thisValueConverter == null)
{
Type valueType = rootDatumConverterFactory.GetBestNativeTypeForDatum(kvp.val);
thisValueConverter = GetConverter(valueType);
}
retval[kvp.key] = (TValue)thisValueConverter.ConvertDatum(kvp.val);
}
return(retval);
}
public void TestFixtureSetUp()
{
datumConverter = new AggregateDatumConverterFactory(
PrimitiveDatumConverterFactory.Instance,
NullableDatumConverterFactory.Instance
).Get<int?>();
}
public void TestFixtureSetUp()
{
datumConverter = new AggregateDatumConverterFactory(
PrimitiveDatumConverterFactory.Instance,
NullableDatumConverterFactory.Instance
).Get <int?>();
}
public QueryEnumerator(Connection connection, IDatumConverterFactory datumConverterFactory, ISequenceQuery <T> queryObject)
{
this.connection = connection;
this.datumConverterFactory = datumConverterFactory;
this.datumConverter = datumConverterFactory.Get <T>();
this.queryObject = queryObject;
this.stackTrace = new StackTrace(true);
}
public QueryEnumerator(Connection connection, IQueryConverter queryConverter, ISequenceQuery <T> queryObject)
{
this.connection = connection;
this.queryConverter = queryConverter;
this.datumConverter = queryConverter.Get <T>();
this.queryObject = queryObject;
this.stackTrace = new StackTrace(true);
}
private IDatumConverter GetConverter(Type type)
{
IDatumConverter valueConverter = null;
if (datumConverterCache.TryGetValue(type, out valueConverter))
{
return(valueConverter);
}
datumConverterCache[type] = valueConverter = rootDatumConverterFactory.Get(type);
return(valueConverter);
}
public NullableDatumConverter(IDatumConverterFactory rootDatumConverterFactory)
{
this.innerConverter = rootDatumConverterFactory.Get <T>(rootDatumConverterFactory);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (typeof(T).IsEnum)
{
datumConverter = EnumDatumConverter <T> .Instance.Value;
}
return(datumConverter != null);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
//I guess we could have some more specific checks here
//but if we get here last in the NewtonsoftSerializer order, then
//I suppose we can handle it if no preceding converters could handle it.
//makes no difference to Newtonsoft, but base class constructor
//checks this constraint and throws if it's not exactly a Value type converter...
if (typeof(T).IsValueType)
{
datumConverter = new NewtonsoftValueDatumConverter <T>();
return(true);
}
datumConverter = new NewtonsoftReferenceDatumConverter <T>();
return(true);
}
public NamedValueDictionaryKeysDatumConverter(IDatumConverterFactory rootDatumConverterFactory)
{
arrayDatumConverter = rootDatumConverterFactory.Get <string[]>();
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (typeof(T) == typeof(Uri))
{
datumConverter = (IDatumConverter <T>)UriDatumConverter.Instance.Value;
}
return(datumConverter != null);
}
public bool TryGet(Type datumType, IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter datumConverter)
{
return(delegatedDatumConverterFactory.TryGet(datumType, rootDatumConverterFactory, out datumConverter));
}
public void TestFixtureSetUp()
{
datumConverter = TimeSpanDatumConverterFactory.Instance.Get<TimeSpan>();
}
public abstract bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter);
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (rootDatumConverterFactory == null)
{
throw new ArgumentNullException("rootDatumConverterFactory");
}
if (typeof(T) != typeof(ITestInterface))
{
return(false);
}
datumConverter = (IDatumConverter <T>) new TestInterfaceDatumConverter();
return(true);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (typeof(T) == typeof(Object))
{
datumConverter = (IDatumConverter <T>) new ObjectDatumConverter(rootDatumConverterFactory);
}
return(datumConverter != null);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (rootDatumConverterFactory == null)
{
throw new ArgumentNullException("rootDatumConverterFactory");
}
if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(Nullable <>))
{
Type converterType = typeof(NullableDatumConverter <>).MakeGenericType(typeof(T).GetGenericArguments()[0]);
datumConverter = (IDatumConverter <T>)Activator.CreateInstance(converterType, rootDatumConverterFactory);
return(true);
}
else
{
return(false);
}
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
foreach (var factory in datumConverterFactories)
{
if (factory.TryGet <T>(rootDatumConverterFactory, out datumConverter))
{
return(true);
}
}
return(false);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
if (typeof(T) == typeof(int))
{
datumConverter = Substitute.For <IDatumConverter <T> >();
return(true);
}
else
{
datumConverter = null;
return(false);
}
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (typeof(T) == typeof(Bound))
{
datumConverter = (IDatumConverter <T>)BoundEnumDatumConverter.Instance;
}
return(datumConverter != null);
}
public static bool TryGet(this IDatumConverterFactory datumConverterFactory, Type datumType, out IDatumConverter datumConverter)
{
return(datumConverterFactory.TryGet(datumType, datumConverterFactory, out datumConverter));
}
public void TestFixtureSetUp()
{
datumConverter = TimeSpanDatumConverterFactory.Instance.Get <TimeSpan>();
}
public static bool TryGet <T>(this IDatumConverterFactory datumConverterFactory, out IDatumConverter <T> datumConverter)
{
return(datumConverterFactory.TryGet <T>(datumConverterFactory, out datumConverter));
}
// This is really ugly, using a helper class and reflection to call the generic TryGet<T> method. But,
// I can't see any alternative due to the generic out parameter, and I'm making the assumptions that
// (a) non-generic version of TryGet will be less frequently used than the generic version, and (b) the
// generic version is easier to write, so the non-generic version should be the uglier one.
public bool TryGet(Type datumType, IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter datumConverter)
{
var helperType = typeof(GenericHelper <>).MakeGenericType(datumType);
var helperMethod = helperType.GetMethod("TryGet", BindingFlags.Public | BindingFlags.Static);
var retval = (Tuple <bool, IDatumConverter>)helperMethod.Invoke(null, new object[] { this, rootDatumConverterFactory });
datumConverter = retval.Item2;
return(retval.Item1);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
if (rootDatumConverterFactory == null)
{
throw new ArgumentNullException("rootDatumConverterFactory");
}
datumConverter = null;
if (typeof(CompoundIndexKey).IsAssignableFrom(typeof(T)))
{
var retval = Activator.CreateInstance(
typeof(CompoundIndexKeyDatumConverterShim <>).MakeGenericType(typeof(T)),
new object[] { rootDatumConverterFactory }
);
datumConverter = (IDatumConverter <T>)retval;
}
return(datumConverter != null);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (rootDatumConverterFactory == null)
{
throw new ArgumentNullException("rootDatumConverterFactory");
}
if (!IsTypeSupported(typeof(T)))
{
return(false);
}
datumConverter = new TupleConverter <T>(rootDatumConverterFactory);
return(true);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
if (rootDatumConverterFactory == null)
{
throw new ArgumentNullException("rootDatumConverterFactory");
}
datumConverter = null;
var dataContractAttribute = typeof(T).GetCustomAttribute <DataContractAttribute>();
if (dataContractAttribute == null)
{
return(false);
}
if (typeof(T).IsEnum)
{
// [DataContract] on an enum type isn't supported by this datum converter. It possibly should be,
// as using the [EnumValue] attribute allows users to assign arbitrary text values to enums. (#146)
return(false);
}
Type datumConverterType = TypeCache <T> .Instance.Value;
datumConverter = (IDatumConverter <T>)Activator.CreateInstance(datumConverterType, rootDatumConverterFactory);
return(true);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (typeof(T) == typeof(string))
{
datumConverter = (IDatumConverter <T>)StringDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(char))
{
datumConverter = (IDatumConverter <T>)CharDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(bool))
{
datumConverter = (IDatumConverter <T>)BoolDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(double))
{
datumConverter = (IDatumConverter <T>)DoubleDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(int))
{
datumConverter = (IDatumConverter <T>)IntDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(uint))
{
datumConverter = (IDatumConverter <T>)UnsignedIntDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(long))
{
datumConverter = (IDatumConverter <T>)LongDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(ulong))
{
datumConverter = (IDatumConverter <T>)UnsignedLongDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(short))
{
datumConverter = (IDatumConverter <T>)ShortDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(ushort))
{
datumConverter = (IDatumConverter <T>)UnsignedShortDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(float))
{
datumConverter = (IDatumConverter <T>)FloatDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(decimal))
{
datumConverter = (IDatumConverter <T>)DecimalDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(byte))
{
datumConverter = (IDatumConverter <T>)ByteDatumConverter.Instance.Value;
}
else if (typeof(T) == typeof(sbyte))
{
datumConverter = (IDatumConverter <T>)SignedByteDatumConverter.Instance.Value;
}
return(datumConverter != null);
}
public override bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
datumConverter = null;
if (rootDatumConverterFactory == null)
{
throw new ArgumentNullException("rootDatumConverterFactory");
}
if (typeof(T).IsGenericType &&
typeof(T).GetGenericTypeDefinition() == typeof(Dictionary <,>) &&
typeof(T).GetGenericArguments() [0] == typeof(string))
{
var specificType = typeof(NamedValueDictionaryDatumConverter <>).MakeGenericType(typeof(T).GetGenericArguments()[1]);
var dc = Activator.CreateInstance(specificType, new object[] { rootDatumConverterFactory });
datumConverter = (IDatumConverter <T>)dc;
return(true);
}
if (typeof(T).IsGenericType &&
typeof(T).GetGenericTypeDefinition() == typeof(Dictionary <,> .KeyCollection) &&
typeof(T).GetGenericArguments() [0] == typeof(string))
{
var specificType = typeof(NamedValueDictionaryKeysDatumConverter <>).MakeGenericType(typeof(T).GetGenericArguments()[1]);
var dc = Activator.CreateInstance(specificType, new object[] { rootDatumConverterFactory });
datumConverter = (IDatumConverter <T>)dc;
return(true);
}
if (typeof(T).IsGenericType &&
typeof(T).GetGenericTypeDefinition() == typeof(Dictionary <,> .ValueCollection) &&
typeof(T).GetGenericArguments()[0] == typeof(string))
{
var dictionaryConverterType = typeof(NamedValueDictionaryDatumConverter <>).MakeGenericType(typeof(T).GetGenericArguments()[1]);
var dictionaryConverter = Activator.CreateInstance(dictionaryConverterType, new object[] { rootDatumConverterFactory });
var specificType = typeof(NamedValueDictionaryValuesDatumConverter <>).MakeGenericType(typeof(T).GetGenericArguments()[1]);
var dc = Activator.CreateInstance(specificType, new object[] { dictionaryConverter });
datumConverter = (IDatumConverter <T>)dc;
return(true);
}
return(false);
}
public bool TryGet <T>(IDatumConverterFactory rootDatumConverterFactory, out IDatumConverter <T> datumConverter)
{
return(delegatedDatumConverterFactory.TryGet <T>(rootDatumConverterFactory, out datumConverter));
}
public IListDatumConverter(IDatumConverterFactory rootDatumConverterFactory)
{
this.arrayDatumConverter = new ArrayDatumConverter <T[]>(rootDatumConverterFactory);
}
