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); }