public IFieldReader GetReader(System.Type type)
{
IConverter standardConverter = this.GetStandardConverter(type);
if (standardConverter != null)
{
return((IFieldReader) new CustomReader(standardConverter));
}
if (type.IsEnum && Enum.GetUnderlyingType(type) == typeof(uint))
{
return((IFieldReader) new CustomReader((IConverter) new ToUIntEnumConverter(type)));
}
IType type1 = TypeFactory.Basic(type.FullName);
if (type.IsEnum)
{
type1 = NHibernateUtil.Enum(type);
}
else if (NHibernateConverterProvider.IsNullableEnum(type))
{
type1 = NHibernateUtil.Enum(type.GetGenericArguments()[0]);
}
if (type1 == null)
{
return((IFieldReader)null);
}
if (!(type1 is NullableType))
{
throw new ArgumentException("Invalid Type must be nullable - Found: " + (object)type1);
}
return((IFieldReader) new NullableTypeReader((NullableType)type1));
}
public void EqualsFalse()
{
IType type = NHibernateUtil.Enum(typeof(A));
A lhs = A.One;
A rhs = A.Two;
Assert.IsFalse(type.IsEqual(lhs, rhs, EntityMode.Poco));
}
public void EqualsFalseSameUnderlyingValue()
{
IType type = NHibernateUtil.Enum(typeof(A));
A lhs = A.One;
B rhs = B.One;
Assert.IsFalse(type.IsEqual(lhs, rhs, EntityMode.Poco));
}
public void EqualsTrue()
{
IType type = NHibernateUtil.Enum(typeof(A));
A lhs = A.One;
A rhs = A.One;
Assert.IsTrue(type.IsEqual(lhs, rhs));
}
protected override IQueryOver <UDSRepository, UDSRepository> MappingProjection(IQueryOver <UDSRepository, UDSRepository> queryOver)
{
UDSRepositoryModel udsModel = null;
queryOver
.SelectList(list => list
.Select(x => x.Id).WithAlias(() => udsModel.Id)
.Select(x => x.ActiveDate).WithAlias(() => udsModel.ActiveDate)
.Select(x => x.ExpiredDate).WithAlias(() => udsModel.ExpiredDate)
.Select(x => x.ModuleXML).WithAlias(() => udsModel.ModuleXML)
.Select(x => x.Name).WithAlias(() => udsModel.Name)
.Select(Projections.Cast(
NHibernateUtil.Enum(typeof(UDSRepositoryStatus)),
Projections.Property("Status")).WithAlias(() => udsModel.Status))
.Select(x => x.Version).WithAlias(() => udsModel.Version));
return(queryOver);
}
public IFieldReader GetReader(Type type)
{
var stdConv = GetStandardConverter(type);
if (stdConv != null)
{
return(new CustomReader(stdConv));
}
if (type.IsEnum && (Enum.GetUnderlyingType(type)) == typeof(uint))
{
return(new CustomReader(new ToUIntEnumConverter(type)));
}
var hibernateType = TypeFactory.Basic(type.FullName);
if (type.IsEnum)
{
hibernateType = NHibernateUtil.Enum(type);
}
else if (IsNullableEnum(type))
{
hibernateType = NHibernateUtil.Enum(type.GetGenericArguments()[0]);
}
if (hibernateType != null)
{
if (!(hibernateType is NullableType))
{
throw new ArgumentException("Invalid Type must be nullable - Found: " + hibernateType);
}
return(new NullableTypeReader((NullableType)hibernateType));
}
return(null);
}
public void PropertiesSet()
{
TestDetachedQuery tdq = new TestDetachedQuery();
tdq.SetMaxResults(10).SetFirstResult(5).SetCacheable(true).SetReadOnly(true).SetTimeout(444).SetFlushMode(
FlushMode.Auto).SetCacheRegion("A_REGION").SetResultTransformer(new AliasToBeanResultTransformer(typeof(NoFoo))).
SetIgnoreUknownNamedParameters(true).SetComment(MyComment);
Assert.AreEqual(10, tdq.Selection.MaxRows);
Assert.AreEqual(5, tdq.Selection.FirstRow);
Assert.AreEqual(444, tdq.Selection.Timeout);
Assert.IsTrue(tdq.Cacheable);
Assert.IsTrue(tdq.ReadOnly);
Assert.AreEqual(FlushMode.Auto, tdq.FlushMode);
Assert.AreEqual("A_REGION", tdq.CacheRegion);
Assert.IsNotNull(tdq.ResultTransformer);
Assert.IsTrue(tdq.ShouldIgnoredUnknownNamedParameters);
Assert.That(tdq.Comment, Is.EqualTo(MyComment));
tdq.SetLockMode("LM1", LockMode.Upgrade);
tdq.SetLockMode("LM2", LockMode.Write);
Assert.AreEqual(2, tdq.LockModes.Count);
Assert.IsTrue(tdq.LockModes.ContainsKey("LM1"));
Assert.AreEqual(LockMode.Upgrade, tdq.LockModes["LM1"]);
Assert.IsTrue(tdq.LockModes.ContainsKey("LM2"));
Assert.AreEqual(LockMode.Write, tdq.LockModes["LM2"]);
tdq.SetProperties(new Foo("Pallino", "Pinco"));
tdq.SetProperties(new Foo("Fulano", "De Tal"));
Assert.AreEqual(2, tdq.OptionalUntypeParams.Count);
Assert.IsTrue(tdq.OptionalUntypeParams[0].Equals(new Foo("Pallino", "Pinco")));
Assert.IsTrue(tdq.OptionalUntypeParams[1].Equals(new Foo("Fulano", "De Tal")));
tdq.SetAnsiString(1, "");
tdq.SetBinary(2, new byte[] { });
tdq.SetBoolean(3, false);
tdq.SetByte(4, 255);
tdq.SetCharacter(5, 'A');
tdq.SetDateTime(6, DateTime.MaxValue);
tdq.SetDecimal(7, 10.15m);
tdq.SetDouble(8, 8.1f);
tdq.SetEntity(9, new Foo("Fulano", "De Tal"));
tdq.SetEnum(10, FlushMode.Auto);
tdq.SetInt16(11, 1);
tdq.SetInt32(12, 1);
tdq.SetInt64(13, 1);
tdq.SetSingle(14, 1.1f);
tdq.SetString(15, "");
tdq.SetTime(16, DateTime.Now);
tdq.SetTimestamp(17, DateTime.Now);
tdq.SetGuid(18, Guid.Empty);
Assert.IsTrue(tdq.PosParams[1].Type.Equals(NHibernateUtil.AnsiString));
Assert.IsTrue(tdq.PosParams[2].Type.Equals(NHibernateUtil.Binary));
Assert.IsTrue(tdq.PosParams[3].Type.Equals(NHibernateUtil.Boolean));
Assert.IsTrue(tdq.PosParams[4].Type.Equals(NHibernateUtil.Byte));
Assert.IsTrue(tdq.PosParams[5].Type.Equals(NHibernateUtil.Character));
Assert.IsTrue(tdq.PosParams[6].Type.Equals(NHibernateUtil.DateTime));
Assert.IsTrue(tdq.PosParams[7].Type.Equals(NHibernateUtil.Decimal));
Assert.IsTrue(tdq.PosParams[8].Type.Equals(NHibernateUtil.Double));
Assert.IsTrue(tdq.PosParams[9].Type.Equals(NHibernateUtil.Entity(typeof(Foo))));
Assert.IsTrue(tdq.PosParams[10].Type.Equals(NHibernateUtil.Enum(typeof(FlushMode))));
Assert.IsTrue(tdq.PosParams[11].Type.Equals(NHibernateUtil.Int16));
Assert.IsTrue(tdq.PosParams[12].Type.Equals(NHibernateUtil.Int32));
Assert.IsTrue(tdq.PosParams[13].Type.Equals(NHibernateUtil.Int64));
Assert.IsTrue(tdq.PosParams[14].Type.Equals(NHibernateUtil.Single));
Assert.IsTrue(tdq.PosParams[15].Type.Equals(NHibernateUtil.String));
Assert.IsTrue(tdq.PosParams[16].Type.Equals(NHibernateUtil.Time));
Assert.IsTrue(tdq.PosParams[17].Type.Equals(NHibernateUtil.Timestamp));
Assert.IsTrue(tdq.PosParams[18].Type.Equals(NHibernateUtil.Guid));
tdq.SetAnsiString("1", "");
tdq.SetBinary("2", new byte[] { });
tdq.SetBoolean("3", false);
tdq.SetByte("4", 255);
tdq.SetCharacter("5", 'A');
tdq.SetDateTime("6", DateTime.MaxValue);
tdq.SetDecimal("7", 10.15m);
tdq.SetDouble("8", 8.1f);
tdq.SetEntity("9", new Foo("Fulano", "De Tal"));
tdq.SetEnum("10", FlushMode.Auto);
tdq.SetInt16("11", 1);
tdq.SetInt32("12", 1);
tdq.SetInt64("13", 1);
tdq.SetSingle("14", 1.1f);
tdq.SetString("15", "");
tdq.SetTime("16", DateTime.Now);
tdq.SetTimestamp("17", DateTime.Now);
tdq.SetGuid("18", Guid.Empty);
Assert.IsTrue(tdq.NamedParams["1"].Type.Equals(NHibernateUtil.AnsiString));
Assert.IsTrue(tdq.NamedParams["2"].Type.Equals(NHibernateUtil.Binary));
Assert.IsTrue(tdq.NamedParams["3"].Type.Equals(NHibernateUtil.Boolean));
Assert.IsTrue(tdq.NamedParams["4"].Type.Equals(NHibernateUtil.Byte));
Assert.IsTrue(tdq.NamedParams["5"].Type.Equals(NHibernateUtil.Character));
Assert.IsTrue(tdq.NamedParams["6"].Type.Equals(NHibernateUtil.DateTime));
Assert.IsTrue(tdq.NamedParams["7"].Type.Equals(NHibernateUtil.Decimal));
Assert.IsTrue(tdq.NamedParams["8"].Type.Equals(NHibernateUtil.Double));
Assert.IsTrue(tdq.NamedParams["9"].Type.Equals(NHibernateUtil.Entity(typeof(Foo))));
Assert.IsTrue(tdq.NamedParams["10"].Type.Equals(NHibernateUtil.Enum(typeof(FlushMode))));
Assert.IsTrue(tdq.NamedParams["11"].Type.Equals(NHibernateUtil.Int16));
Assert.IsTrue(tdq.NamedParams["12"].Type.Equals(NHibernateUtil.Int32));
Assert.IsTrue(tdq.NamedParams["13"].Type.Equals(NHibernateUtil.Int64));
Assert.IsTrue(tdq.NamedParams["14"].Type.Equals(NHibernateUtil.Single));
Assert.IsTrue(tdq.NamedParams["15"].Type.Equals(NHibernateUtil.String));
Assert.IsTrue(tdq.NamedParams["16"].Type.Equals(NHibernateUtil.Time));
Assert.IsTrue(tdq.NamedParams["17"].Type.Equals(NHibernateUtil.Timestamp));
Assert.IsTrue(tdq.NamedParams["18"].Type.Equals(NHibernateUtil.Guid));
tdq.SetParameter(10, 123456m);
Assert.AreEqual(1, tdq.PosUntypeParams.Count);
Assert.IsTrue(tdq.PosUntypeParams.ContainsKey(10));
tdq.SetParameter("Any", 123456m);
Assert.AreEqual(1, tdq.NamedUntypeParams.Count);
Assert.IsTrue(tdq.NamedUntypeParams.ContainsKey("Any"));
tdq.SetParameterList("UntypedList", new int[] { 1, 2, 3 });
Assert.IsTrue(tdq.NamedUntypeListParams.ContainsKey("UntypedList"));
tdq.SetParameterList("TypedList", new Int64[] { 1, 2, 3 }, NHibernateUtil.Int64);
Assert.IsTrue(tdq.NamedListParams.ContainsKey("TypedList"));
Assert.IsNotNull((tdq.NamedListParams["TypedList"].Value as IEnumerable));
}
public IQuery SetEnum(string name, Enum val)
{
SetParameter(name, val, NHibernateUtil.Enum(val.GetType()));
return(this);
}
public IQuery SetEnum(int position, Enum val)
{
SetParameter(position, val, NHibernateUtil.Enum(val.GetType()));
return(this);
}
public BitwiseExpression(string propertyName, object value, string @operator, string op)
: base(new SimpleExpression(propertyName, value, @operator), Expression.Sql("?", value, NHibernateUtil.Enum(value.GetType())))
{
Op = op;
}
/// <summary>
/// Uses heuristics to deduce a NHibernate type given a string naming the
/// type.
/// </summary>
/// <param name="typeName"></param>
/// <returns>An instance of <c>NHibernate.Type.IType</c></returns>
/// <remarks>
/// When looking for the NHibernate type it will look in the cache of the Basic types first.
/// If it doesn't find it in the cache then it uses the typeName to get a reference to the
/// Class (Type in .NET). Once we get the reference to the .NET class we check to see if it
/// implements IType, ICompositeUserType, IUserType, ILifecycle (Association), or
/// IPersistentEnum. If none of those are implemented then we will serialize the Type to the
/// database using NHibernate.Type.SerializableType(typeName)
/// </remarks>
public static IType HeuristicType(string typeName)
{
IType type = TypeFactory.Basic(typeName);
if (type == null)
{
string[] parsedTypeName;
TypeClassification typeClassification = GetTypeClassification(typeName);
if (typeClassification == TypeClassification.Length)
{
parsedTypeName = typeName.Split(lengthSplit);
}
else if (typeClassification == TypeClassification.PrecisionScale)
{
parsedTypeName = typeName.Split(precisionScaleSplit);
}
else
{
parsedTypeName = new string[] { typeName };
}
System.Type typeClass;
try
{
typeClass = ReflectHelper.ClassForName(parsedTypeName[0]); //typeName);
}
catch (Exception)
{
typeClass = null;
}
if (typeClass != null)
{
if (typeof(IType).IsAssignableFrom(typeClass))
{
try
{
type = ( IType )Activator.CreateInstance(typeClass);
}
catch (Exception e)
{
throw new MappingException("Could not instantiate IType " + typeClass.Name + ": " + e, e);
}
}
else if (typeof(ICompositeUserType).IsAssignableFrom(typeClass))
{
type = new CompositeCustomType(typeClass);
}
else if (typeof(IUserType).IsAssignableFrom(typeClass))
{
type = new CustomType(typeClass);
}
else if (typeof(ILifecycle).IsAssignableFrom(typeClass))
{
type = NHibernateUtil.Entity(typeClass);
}
else if (typeClass.IsEnum)
{
type = NHibernateUtil.Enum(typeClass);
}
else if (typeClass.IsSerializable)
{
if (typeClassification == TypeClassification.Length)
{
type = GetSerializableType(typeClass, Int32.Parse(parsedTypeName[1]));
}
else
{
type = GetSerializableType(typeClass);
}
}
}
}
return(type);
}
private BitwiseFlags(string propertyName, object value, string op) :
base(new SimpleExpression(propertyName, value, op),
Expression.Sql("?", value, NHibernateUtil.Enum(value.GetType())))
{
}
private static IType[] GetTypes(object value)
{
var type = NHibernateUtil.Enum(value.GetType());
return(new IType[] { type });
}