private bool CheckIfCollectionContainsItem(IEnumerable collection)
{
foreach (var item in collection)
{
if (item == null && TheObject == null && _oid == null)
{
return(true);
}
if (Equals(item, TheObject))
{
return(true);
}
if (_oid == null || item == null)
{
continue;
}
if (!OdbType.IsNative(item.GetType()))
{
continue;
}
if (Equals(item, _oid))
{
return(true);
}
}
return(false);
}
public void It_should_extend_class_info_with_new_attribute_info()
{
Assert.That(_classInfo.Attributes.Count, Is.EqualTo(3));
var attributeInfo = _classInfo.GetAttributeInfoFromName(_fieldName);
Assert.That(attributeInfo, Is.Not.Null);
Assert.That(attributeInfo.GetName(), Is.EqualTo(_fieldName));
Assert.That(attributeInfo.GetAttributeType(), Is.EqualTo(OdbType.GetFromClass(_fieldType)));
}
public virtual void Test3()
{
var array1 = new[] { 1, 2 };
AssertEquals(OdbType.Array, OdbType.GetFromClass(array1.GetType()));
AssertEquals(OdbType.Integer, OdbType.GetFromClass(array1.GetType()).SubType);
var array2 = new[] { "1", "2" };
AssertEquals(OdbType.Array, OdbType.GetFromClass(array2.GetType()));
AssertEquals(OdbType.String, OdbType.GetFromClass(array2.GetType()).SubType);
}
public void Check_type_conversion()
{
AssertEquals(OdbType.Integer, OdbType.GetFromClass(typeof(int)));
AssertEquals(OdbType.Boolean, OdbType.GetFromClass(typeof(bool)));
AssertEquals(OdbType.Byte, OdbType.GetFromClass(typeof(byte)));
AssertEquals(OdbType.Character, OdbType.GetFromClass(typeof(char)));
AssertEquals(OdbType.Double, OdbType.GetFromClass(typeof(double)));
AssertEquals(OdbType.Float, OdbType.GetFromClass(typeof(float)));
AssertEquals(OdbType.Long, OdbType.GetFromClass(typeof(long)));
AssertEquals(OdbType.Short, OdbType.GetFromClass(typeof(short)));
AssertEquals(OdbType.String, OdbType.GetFromClass(typeof(string)));
AssertEquals(OdbType.Decimal, OdbType.GetFromClass(typeof(Decimal)));
}
private object BuildOneInstance(NativeObjectInfo objectInfo)
{
if (objectInfo.IsAtomicNativeObject())
{
return(BuildOneInstance((AtomicNativeObjectInfo)objectInfo));
}
if (objectInfo.IsArrayObject())
{
return(BuildArrayInstance((ArrayObjectInfo)objectInfo));
}
if (objectInfo.IsNull())
{
return(null);
}
throw new OdbRuntimeException(
NDatabaseError.InstanceBuilderNativeType.AddParameter(OdbType.GetNameFromId(objectInfo.GetOdbTypeId())));
}
private AbstractObjectInfo GetNativeObjectInfoInternal(OdbType type, object o, bool recursive,
IDictionary<object, NonNativeObjectInfo>
alreadyReadObjects, IIntrospectionCallback callback)
{
AbstractObjectInfo aoi = null;
if (type.IsAtomicNative())
{
if (o == null)
aoi = new NullNativeObjectInfo(type.Id);
else
aoi = new AtomicNativeObjectInfo(o, type.Id);
}
else if (type.IsArray())
{
if (o == null)
aoi = new ArrayObjectInfo(null);
else
{
// Gets the type of the elements of the array
var realArrayClassName = OdbClassNameResolver.GetFullName(o.GetType().GetElementType());
var arrayObjectInfo = recursive
? IntrospectArray(o, alreadyReadObjects, type, callback)
: new ArrayObjectInfo((object[]) o);
arrayObjectInfo.SetRealArrayComponentClassName(realArrayClassName);
aoi = arrayObjectInfo;
}
}
else if (type.IsEnum())
{
var enumObject = (Enum) o;
// Here we must check if the enum is already in the meta model. Enum must be stored in the meta
// model to optimize its storing as we need to keep track of the enum class
// for each enum stored. So instead of storing the enum class name, we can store enum class id, a long
// instead of the full enum class name string
var classInfo = GetClassInfo(enumObject.GetType());
var enumValue = enumObject.ToString();
aoi = new EnumNativeObjectInfo(classInfo, enumValue);
}
return aoi;
}
public void It_should_contain_valid_null_type()
{
var odbType = OdbType.Null;
Assert.That(odbType.Id, Is.EqualTo(OdbType.NullId));
Assert.That(odbType.Name, Is.EqualTo("null"));
Assert.That(odbType.Size, Is.EqualTo(1));
Assert.That(odbType.SubType, Is.Null);
Assert.That(odbType.GetNativeClass(), Is.Null);
Assert.That(odbType.IsArray(), Is.False);
Assert.That(odbType.IsAtomicNative(), Is.False);
Assert.That(odbType.IsEnum(), Is.False);
Assert.That(odbType.IsNative(), Is.True);
Assert.That(odbType.IsNonNative(), Is.False);
Assert.That(OdbType.IsNull(odbType.Id), Is.True);
}
/// <summary>
/// Builds an instance of an array
/// </summary>
private object BuildArrayInstance(ArrayObjectInfo aoi)
{
// first check if array element type is native (int,short, for example)
var type = OdbType.GetFromName(aoi.GetRealArrayComponentClassName());
var arrayClazz = type.GetNativeClass();
object array = Array.CreateInstance(arrayClazz, aoi.GetArray().Length);
for (var i = 0; i < aoi.GetArrayLength(); i++)
{
var abstractObjectInfo = (AbstractObjectInfo)aoi.GetArray()[i];
if (abstractObjectInfo == null || abstractObjectInfo.IsDeletedObject() || abstractObjectInfo.IsNull())
{
continue;
}
var instance = BuildOneInstance(abstractObjectInfo);
((Array)array).SetValue(instance, i);
}
return(array);
}
public ArrayObjectInfo(IEnumerable array, OdbType type, int componentId) : base(array, type)
{
_realArrayComponentClassName = OdbType.DefaultArrayComponentClassName;
_componentTypeId = componentId;
}
protected NativeObjectInfo(object @object, OdbType odbType) : base(odbType)
{
TheObject = @object;
}
private static object ThrowIfNotFound(int odbTypeId)
{
throw new OdbRuntimeException(
NDatabaseError.InstanceBuilderNativeTypeInCollectionNotSupported.AddParameter(
OdbType.GetNameFromId(odbTypeId)));
}
private static ArrayObjectInfo IntropectAtomicNativeArray(object array, OdbType type)
{
var length = ((Array) array).GetLength(0);
var arrayCopy = new object[length];
for (var i = 0; i < length; i++)
{
var o = ((Array) array).GetValue(i);
if (o != null)
{
// If object is not null, try to get the exact type
var typeId = OdbType.GetFromClass(o.GetType()).Id;
var atomicNativeObjectInfo = new AtomicNativeObjectInfo(o, typeId);
arrayCopy[i] = atomicNativeObjectInfo;
}
else
{
// Else take the declared type
arrayCopy[i] = new NullNativeObjectInfo(type.Id);
}
}
return new ArrayObjectInfo(arrayCopy, OdbType.Array, type.Id);
}
private ArrayObjectInfo IntrospectArray(object array,
IDictionary<object, NonNativeObjectInfo> alreadyReadObjects,
OdbType odbType, IIntrospectionCallback callback)
{
var length = ((Array) array).GetLength(0);
var elementType = array.GetType().GetElementType();
var type = OdbType.GetFromClass(elementType);
if (type.IsAtomicNative())
return IntropectAtomicNativeArray(array, type);
var arrayCopy = new object[length];
for (var i = 0; i < length; i++)
{
var o = ((Array) array).GetValue(i);
if (o != null)
{
var classInfo = GetClassInfo(o.GetType());
var abstractObjectInfo = GetObjectInfo(o, classInfo, true, alreadyReadObjects, callback);
arrayCopy[i] = abstractObjectInfo;
}
else
arrayCopy[i] = NullNativeObjectInfo.GetInstance();
}
return new ArrayObjectInfo(arrayCopy, odbType, type.Id);
}
private bool IsEquivalent(OdbType type2)
{
return (_id == IntegerId && type2._id == IntegerId);
}
public static bool TypesAreCompatible(OdbType type1, OdbType type2)
{
if (type1 == null || type2 == null)
return false;
if (type1.IsArray() && type2.IsArray())
return TypesAreCompatible(type1.SubType, type2.SubType);
if (type1.Name.Equals(type2.Name))
return true;
if (type1.IsEnum() && type2.IsEnum())
return type1.GetNativeClass() == type2.GetNativeClass();
if (type1.IsNative() && type2.IsNative())
return type1.IsEquivalent(type2);
if (type1.IsNonNative() && type2.IsNonNative())
return (type1.GetNativeClass() == type2.GetNativeClass()) ||
(type1.GetNativeClass().IsAssignableFrom(type2.GetNativeClass()));
return false;
}
public static OdbType GetFromClass(Type clazz)
{
if (clazz.IsEnum)
return new OdbType(Enum._isPrimitive, EnumId, OdbClassNameResolver.GetFullName(clazz), 0);
var className = OdbClassNameResolver.GetFullName(clazz);
// First check if it is a 'default type'
OdbType odbType;
var success = TypesByName.TryGetValue(className, out odbType);
if (success)
return odbType;
// Then check if it is a 'non default type'
success = CacheOfTypesByName.TryGetValue(className, out odbType);
if (success)
return odbType;
if (clazz.IsArray)
{
var type = new OdbType(Array._isPrimitive, ArrayId, Array.Name, 0)
{_subType = GetFromClass(clazz.GetElementType())};
return CacheOfTypesByName.GetOrAdd(className, type);
}
var nonNative = new OdbType(NonNative._isPrimitive, NonNativeId, className, 0);
return CacheOfTypesByName.GetOrAdd(className, nonNative);
}
