private ClassInfo NewUserClassMeta(IReflectClass claxx) { ClassInfo classMeta = ClassInfo.NewUserClass(claxx.GetName()); classMeta.SetSuperClass(MapSuperclass(claxx)); RegisterClassMeta(claxx.GetName(), classMeta); classMeta.SetFields(MapFields(claxx.GetDeclaredFields(), ShouldStoreTransientFields (claxx))); return classMeta; }
private ClassInfo NewUserClassMeta(IReflectClass claxx) { ClassInfo classMeta = ClassInfo.NewUserClass(claxx.GetName()); classMeta.SetSuperClass(MapSuperclass(claxx)); RegisterClassMeta(claxx.GetName(), classMeta); classMeta.SetFields(MapFields(claxx.GetDeclaredFields(), ShouldStoreTransientFields (claxx))); return(classMeta); }
public virtual ClassInfo GetClassMeta(IReflectClass claxx) { if (IsObjectClass(claxx)) { return ClassInfo.NewSystemClass(claxx.GetName()); } ClassInfo existing = LookupClassMeta(claxx.GetName()); if (existing != null) { return existing; } return NewUserClassMeta(claxx); }
public virtual ClassInfo GetClassMeta(IReflectClass claxx) { if (IsObjectClass(claxx)) { return(ClassInfo.NewSystemClass(claxx.GetName())); } ClassInfo existing = LookupClassMeta(claxx.GetName()); if (existing != null) { return(existing); } return(NewUserClassMeta(claxx)); }
public IObjectClass ObjectClass(object clazz) { string className = null; if (clazz is string) { className = (string)clazz; } else { IReflectClass claxx = ReflectorFor(clazz); if (claxx == null) { return(null); } className = claxx.GetName(); } if (ReflectPlatform.FullyQualifiedName(typeof(object)).Equals(className)) { throw new ArgumentException("Configuration of the Object class is not supported." ); } Hashtable4 xClasses = ExceptionalClasses(); Config4Class c4c = (Config4Class)xClasses.Get(className); if (c4c == null) { c4c = new Config4Class(this, className); xClasses.Put(className, c4c); } return(c4c); }
private void ThrowUnsupportedAdd(IReflectClass runtimeAncestor) { throw new InvalidOperationException("Unsupported class hierarchy change. Class " + runtimeAncestor.GetName() + " was added to hierarchy of " + _runtimeClass.GetName ()); }
private void AssertFullyQualifiedName(Type clazz) { IReflectClass reflectClass = Platform4.ReflectorForType(clazz).ForClass(clazz); Assert.AreEqual(ReflectPlatform.FullyQualifiedName(clazz), reflectClass.GetName() ); }
private void ThrowUnsupportedAdd(IReflectClass runtimeAncestor) { throw new InvalidOperationException("Unsupported class hierarchy change. Class " + runtimeAncestor.GetName() + " was added to hierarchy of " + _runtimeClass.GetName ()); }
internal QConClass(Transaction trans, QCon parent, QField field, IReflectClass claxx ) : base(trans, parent, field, null) { // C/S if (claxx != null) { ObjectContainerBase container = trans.Container(); _classMetadata = container.ClassMetadataForReflectClass(claxx); if (_classMetadata == null) { // could be an aliased class, try to resolve. string className = claxx.GetName(); string aliasRunTimeName = container.Config().ResolveAliasStoredName(className); if (!className.Equals(aliasRunTimeName)) { _classMetadata = container.ClassMetadataForName(aliasRunTimeName); } } if (claxx.Equals(container._handlers.IclassObject)) { _classMetadata = (ClassMetadata)_classMetadata.TypeHandler(); } } _claxx = claxx; }
public List <TreeGridViewRenderer> ExpandObjectNode(object obj, bool activate) { try { //object obj = Db4oClient.Client.Ext().GetByID(id); if (obj == null) { return(null); } IReflectClass rclass = DataLayerCommon.ReflectClassFor(obj); if (rclass == null) { return(null); } string classname = rclass.GetName(); if (classname != string.Empty) { TraverseObjTree(GetLocalID(obj), classname); } return(listTreeGridViewRenderers); } catch (Exception oEx) { LoggingHelper.HandleException(oEx); return(null); } }
public TreeGridViewRenderer FillValuesInTreeGridViewRenderer(long id, string classname) { TreeGridViewRenderer treeGridViewRenderer = new TreeGridViewRenderer(); try { object currObj = Db4oClient.Client.Ext().GetByID(id); Db4oClient.Client.Ext().Activate(currObj, 1); IReflectClass rclass = DataLayerCommon.ReflectClassForName(classname); IType type = ResolveType(rclass); treeGridViewRenderer.QualifiedName = rclass.GetName(); treeGridViewRenderer.DisplayFieldName = AppendIDTo(type.FullName, id, type); treeGridViewRenderer.FieldName = type.FullName; treeGridViewRenderer.FieldValue = type.DisplayName; treeGridViewRenderer.FieldType = SetFieldType(type); treeGridViewRenderer.ReadOnlyStatus = true; treeGridViewRenderer.ObjectId = id; treeGridViewRenderer.ObjectType = type; } catch (Exception e) { LoggingHelper.HandleException(e); } return(treeGridViewRenderer); }
public void ExpandObjectNode(TreeGridNode node, bool activate) { try { object obj = node.Tag; if (obj == null) { return; } IReflectClass rclass = DataLayerCommon.ReflectClassFor(obj); if (rclass == null) { return; } string classname = rclass.GetName(); if (classname != string.Empty) { TraverseObjTree(ref node, obj, classname); } } catch (Exception oEx) { LoggingHelper.HandleException(oEx); } }
internal QConClass(Transaction trans, QCon parent, QField field, IReflectClass claxx ) : base(trans, parent, field, null) { // C/S if (claxx != null) { ObjectContainerBase container = trans.Container(); _classMetadata = container.ClassMetadataForReflectClass(claxx); if (_classMetadata == null) { // could be an aliased class, try to resolve. string className = claxx.GetName(); string aliasRunTimeName = container.Config().ResolveAliasStoredName(className); if (!className.Equals(aliasRunTimeName)) { _classMetadata = container.ClassMetadataForName(aliasRunTimeName); } } if (claxx.Equals(container._handlers.IclassObject)) { _classMetadata = (ClassMetadata)_classMetadata.TypeHandler(); } } _claxx = claxx; }
private static TypeName NameOf(IReflectClass typeToFind) { var name = TypeNameParser.ParseString(typeToFind.GetName()); if (typeToFind.IsArray() && !name.ArrayOf.HasValue) { return TypeName.CreateArrayOf(name, 1); } return name; }
public virtual void TestInternalClassesAreNotVisible() { IReflectClass[] knownClassArray = Container().KnownClasses(); for (int knownClassIndex = 0; knownClassIndex < knownClassArray.Length; ++knownClassIndex) { IReflectClass knownClass = knownClassArray[knownClassIndex]; AssertIsNotInternal(knownClass.GetName()); } }
public virtual void TestNoPrimitives() { IReflectClass[] knownClassArray = Container().KnownClasses(); for (int knownClassIndex = 0; knownClassIndex < knownClassArray.Length; ++knownClassIndex) { IReflectClass knownClass = knownClassArray[knownClassIndex]; Assert.IsFalse(knownClass.IsPrimitive(), knownClass.GetName()); } }
private IReflectClass PrimitiveClass(IReflectClass baseClass) { Type primitive = (Type)Primitives.Get(baseClass.GetName()); if (primitive != null) { return(baseClass.Reflector().ForClass(primitive)); } return(baseClass); }
private static TypeName NameOf(IReflectClass typeToFind) { var name = TypeNameParser.ParseString(typeToFind.GetName()); if (typeToFind.IsArray() && !name.ArrayOf.HasValue) { return(TypeName.CreateArrayOf(name, 1)); } return(name); }
private ClassMetadata ReadClassMetadata(IReflectClass reflectClazz) { var clazz = (ClassMetadata)_classMetadataByBytes.Remove(GetNameBytes(reflectClazz .GetName())); if (clazz == null) { return(null); } return(ReadClassMetadata(clazz, reflectClazz)); }
private bool IsKnownClass(string expected) { IReflectClass[] knownClassArray = Container().KnownClasses(); for (int knownClassIndex = 0; knownClassIndex < knownClassArray.Length; ++knownClassIndex) { IReflectClass knownClass = knownClassArray[knownClassIndex]; string className = knownClass.GetName(); if (className.Equals(expected)) { return(true); } } return(false); }
public IType Resolve(IReflectClass klass) { if (klass == null) { return null; } string className = klass.GetName(); if (!_resolved.ContainsKey(className)) { _resolved[className] = new TypeImpl(klass, this); } return _resolved[className]; }
public IType Resolve(IReflectClass klass) { if (klass == null) { return(null); } string className = klass.GetName(); if (!_resolved.ContainsKey(className)) { _resolved[className] = new TypeImpl(klass, this); } return(_resolved[className]); }
public virtual void TestValueTypes() { Container().Reflector().ForName("System.Guid, mscorlib"); bool found = false; IReflectClass[] knownClassArray = Container().KnownClasses(); for (int knownClassIndex = 0; knownClassIndex < knownClassArray.Length; ++knownClassIndex) { IReflectClass knownClass = knownClassArray[knownClassIndex]; if (knownClass.GetName().Equals("System.Guid, mscorlib")) { found = true; } } Assert.IsTrue(found); }
private IReflectClass NormalizeFieldClass(RawFieldSpec fieldInfo, IReflectClass fieldClass ) { // TODO: why the following line is necessary? IReflectClass theClass = _stream.Reflector().ForName(fieldClass.GetName()); if (fieldInfo.IsPrimitive()) { theClass = PrimitiveClass(theClass); } if (fieldInfo.IsArray()) { theClass = ArrayClass(theClass); } return(theClass); }
public override bool CreateClassMetadata(ClassMetadata clazz, IReflectClass claxx , ClassMetadata superClazz) { Write(Msg.CreateClass.GetWriterForString(SystemTransaction(), Config().ResolveAliasRuntimeName (claxx.GetName()))); Msg resp = GetResponse(); if (resp == null) { return(false); } if (resp.Equals(Msg.Failed)) { // if the class can not be created on the server, send class meta to the server. SendClassMeta(claxx); resp = GetResponse(); } if (resp.Equals(Msg.Failed)) { if (ConfigImpl.ExceptionsOnNotStorable()) { throw new ObjectNotStorableException(claxx); } return(false); } if (!resp.Equals(Msg.ObjectToClient)) { return(false); } MsgObject message = (MsgObject)resp; StatefulBuffer bytes = message.Unmarshall(); if (bytes == null) { return(false); } bytes.SetTransaction(SystemTransaction()); if (!base.CreateClassMetadata(clazz, claxx, superClazz)) { return(false); } clazz.SetID(message.GetId()); clazz.ReadName1(SystemTransaction(), bytes); ClassCollection().AddClassMetadata(clazz); ClassCollection().ReadClassMetadata(clazz, claxx); return(true); }
private Db4objects.Db4o.Reflect.Generic.GenericClass GenericClass(IReflectClass clazz ) { Db4objects.Db4o.Reflect.Generic.GenericClass ret; string name = clazz.GetName(); if (name.Equals(ReflectPlatform.FullyQualifiedName(typeof(GenericArray)))) { // special case, comparing name because can't compare class == class directly with ReflectClass ret = new GenericArrayClass(this, clazz, name, null); } else { ret = new Db4objects.Db4o.Reflect.Generic.GenericClass(this, clazz, name, null); } return(ret); }
internal ClassMetadata ClassMetadataForReflectClass(IReflectClass reflectClazz) { ClassMetadata cached = (ClassMetadata)_classMetadataByClass.Get(reflectClazz); if (cached != null) { return(cached); } ClassMetadata byName = (ClassMetadata)_classMetadataByName.Get(reflectClazz.GetName ()); if (byName != null) { return(byName); } return(ReadClassMetadata(reflectClazz)); }
public static bool CheckForDatetimeOrString(object expandedObj) { try { IReflectClass refClass = ReflectClassFor(expandedObj);// objectContainer.Ext().Reflector().ForObject(expandedObj); if (refClass != null) { string type = PrimitiveType(refClass.GetName()); return(CommonValues.IsDateTimeOrString(type)); } return(false); } catch (Exception oEx) { LoggingHelper.HandleException(oEx); return(false); } }
public override string ToString() { try { int id = GetID(); string str = "ObjectReference\nID=" + id; object obj = GetObject(); if (obj == null && _class != null) { ObjectContainerBase container = _class.Container(); if (container != null && id > 0) { obj = container.PeekPersisted(container.Transaction, id, container.DefaultActivationDepth (ClassMetadata()), true).ToString(); } } if (obj == null) { str += "\nfor [null]"; } else { string objToString = string.Empty; try { objToString = obj.ToString(); } catch (Exception) { } if (ClassMetadata() != null) { IReflectClass claxx = ClassMetadata().Reflector().ForObject(obj); str += "\n" + claxx.GetName(); } str += "\n" + objToString; } return(str); } catch (Exception) { } return("ObjectReference " + GetID()); }
internal virtual GenericClass EnsureDelegate(IReflectClass clazz) { if (clazz == null) { return(null); } var claxx = (GenericClass )_repository.LookupByName(clazz.GetName()); if (claxx == null) { // We don't have to worry about the superclass, it can be null // because handling is delegated anyway claxx = GenericClass(clazz); _repository.Register(claxx); } return(claxx); }
/// <summary> /// This is to ensure that reflector.forObject(GenericArray) returns an instance of GenericArrayClass instead of GenericClass /// http://tracker.db4o.com/jira/browse/COR-376 /// </summary> public virtual void TestGenericArrayClass() { IExtObjectContainer oc = Fixture().Db(); InitGenericObjects(); IReflectClass elementType = oc.Reflector().ForName(PersonClassname); object array = Reflector().Array().NewInstance(elementType, 5); IReflectClass arrayClass = oc.Reflector().ForObject(array); Assert.IsTrue(arrayClass.IsArray()); Assert.IsTrue(arrayClass is GenericArrayClass); arrayClass = oc.Reflector().ForName(array.GetType().FullName); Assert.IsTrue(arrayClass.IsArray()); Assert.IsTrue(arrayClass is GenericArrayClass); arrayClass = oc.Reflector().ForClass(array.GetType()); Assert.IsTrue(arrayClass.IsArray()); Assert.IsTrue(arrayClass is GenericArrayClass); Assert.AreEqual(arrayClass.GetName(), ReflectPlatform.FullyQualifiedName(array.GetType ())); Assert.AreEqual("(GA) " + elementType.GetName(), array.ToString()); }
private TernaryBool CallConstructorSpecialized(IReflectClass clazz) { Config4Class clazzConfig = _config.ConfigClass(clazz.GetName()); if (clazzConfig != null) { TernaryBool res = clazzConfig.CallConstructor(); if (!res.IsUnspecified()) { return res; } } if (Platform4.IsEnum(_config.Reflector(), clazz)) { return TernaryBool.No; } IReflectClass ancestor = clazz.GetSuperclass(); if (ancestor != null) { return CallConstructorSpecialized(ancestor); } return TernaryBool.Unspecified; }
/// <summary>returns a prototype object for a specific class.</summary> /// <remarks>returns a prototype object for a specific class.</remarks> public virtual object PrototypeForClass(Type clazz) { if (clazz == null) { throw new PrototypesException("Class can not be null"); } IReflectClass claxx = _reflector.ForClass(clazz); if (claxx == null) { throw new PrototypesException("Not found in the reflector: " + clazz); } string className = claxx.GetName(); Prototypes.Prototype prototype = (Prototypes.Prototype)_prototypes.Get(className); if (prototype != null) { return(prototype.Object()); } prototype = new Prototypes.Prototype(this, claxx); _prototypes.Put(className, prototype); return(prototype.Object()); }
public static void SaveValues(long id, string attribName, object newValue, int offset) { try { object targetObject = Db4oClient.Client.Ext().GetByID(id); Db4oClient.Client.Ext().Activate(targetObject, 2); IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject); IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName); IType type = new FieldDetails(rclass.GetName(), attribName).GetFieldType(); object obj = rfield.Get(targetObject); if (obj is IDictionary) { SaveDictionary(targetObject, attribName, newValue, KeyAtIndex((IDictionary)obj, offset / 2)); } else { if (rfield != null && !(rfield is GenericVirtualField || rfield.IsStatic())) { if (type.IsArray || type.IsCollection) { IList list = obj as IList; if (null != list) { list[offset] = newValue; rfield.Set(targetObject, list); } } } } } catch (Exception oEx) { Db4oClient.Client.Rollback(); LoggingHelper.HandleException(oEx); } }
public static List <IReflectField> GetFieldList(IReflectClass aClass) { try { if (aClass == null) { return(null); } List <IReflectField> ret = NonVirtualFieldsFor(aClass); IReflectClass parent = aClass.GetSuperclass(); if (parent != null && !(parent.GetName().StartsWith("System."))) { ret.AddRange(GetFieldList(parent)); } return(ret); } catch (Exception e) { LoggingHelper.HandleException(e); } return(null); }
private TernaryBool CallConstructorSpecialized(IReflectClass clazz) { Config4Class clazzConfig = _config.ConfigClass(clazz.GetName()); if (clazzConfig != null) { TernaryBool res = clazzConfig.CallConstructor(); if (!res.IsUnspecified()) { return(res); } } if (Platform4.IsEnum(_config.Reflector(), clazz)) { return(TernaryBool.No); } IReflectClass ancestor = clazz.GetSuperclass(); if (ancestor != null) { return(CallConstructorSpecialized(ancestor)); } return(TernaryBool.Unspecified); }
internal virtual string ResolveName(IReflectClass claxx) { if (i_nameBytes != null) { var name = _container.StringIO().Read(i_nameBytes); return ConfigImpl().ResolveAliasStoredName(name); } if (claxx != null) { return ConfigImpl().ResolveAliasStoredName(claxx.GetName()); } throw new InvalidOperationException(); }
public override bool CreateClassMetadata(ClassMetadata clazz, IReflectClass claxx , ClassMetadata superClazz) { Write(Msg.CreateClass.GetWriterForString(SystemTransaction(), Config().ResolveAliasRuntimeName (claxx.GetName()))); Msg resp = GetResponse(); if (resp == null) { return false; } if (resp.Equals(Msg.Failed)) { // if the class can not be created on the server, send class meta to the server. SendClassMeta(claxx); resp = GetResponse(); } if (resp.Equals(Msg.Failed)) { if (ConfigImpl.ExceptionsOnNotStorable()) { throw new ObjectNotStorableException(claxx); } return false; } if (!resp.Equals(Msg.ObjectToClient)) { return false; } MsgObject message = (MsgObject)resp; StatefulBuffer bytes = message.Unmarshall(); if (bytes == null) { return false; } bytes.SetTransaction(SystemTransaction()); if (!base.CreateClassMetadata(clazz, claxx, superClazz)) { return false; } clazz.SetID(message.GetId()); clazz.ReadName1(SystemTransaction(), bytes); ClassCollection().AddClassMetadata(clazz); ClassCollection().ReadClassMetadata(clazz, claxx); return true; }
public override ClassMetadata ClassMetadataForReflectClass(IReflectClass claxx) { ClassMetadata classMetadata = base.ClassMetadataForReflectClass(claxx); if (classMetadata != null) { return classMetadata; } string className = Config().ResolveAliasRuntimeName(claxx.GetName()); if (ClassMetadataIdForName(className) == 0) { return null; } return ProduceClassMetadata(claxx); }
internal virtual GenericClass EnsureDelegate(IReflectClass clazz) { if (clazz == null) { return null; } var claxx = (GenericClass ) _repository.LookupByName(clazz.GetName()); if (claxx == null) { // We don't have to worry about the superclass, it can be null // because handling is delegated anyway claxx = GenericClass(clazz); _repository.Register(claxx); } return claxx; }
private GenericClass GenericClass(IReflectClass clazz ) { GenericClass ret; var name = clazz.GetName(); if (name.Equals(ReflectPlatform.FullyQualifiedName(typeof (GenericArray)))) { // special case, comparing name because can't compare class == class directly with ReflectClass ret = new GenericArrayClass(this, clazz, name, null); } else { ret = new GenericClass(this, clazz, name, null); } return ret; }
public ObjectNotStorableException(IReflectClass clazz, string message) : base(clazz .GetName() + ": " + message) { }
private IReflectClass PrimitiveClass(IReflectClass baseClass) { Type primitive = (Type)Primitives.Get(baseClass.GetName()); if (primitive != null) { return baseClass.Reflector().ForClass(primitive); } return baseClass; }
private bool ShouldStoreTransientFields(IReflectClass claxx) { Config4Class configClass = _config.ConfigClass(claxx.GetName()); return(configClass == null ? false : configClass.StoreTransientFields()); }
public ObjectNotStorableException(IReflectClass a_class) : base(Db4objects.Db4o.Internal.Messages .Get(a_class.IsPrimitive() ? 59 : 45, a_class.GetName())) { }
public Prototype(Prototypes _enclosing, IReflectClass claxx) { this._enclosing = _enclosing; this._object = (object)claxx.NewInstance(); if (this._object == null) { throw new PrototypesException("Prototype could not be created for class " + claxx .GetName()); } this.Analyze(this._object, claxx, this._enclosing._recursionDepth, null); }
public bool Match(IReflectClass candidate) { return candidate.GetName().Equals(_className); }
/// <summary> /// analyzes the passed expression and tries to find the path to the /// backing field that is accessed. /// </summary> /// <remarks> /// analyzes the passed expression and tries to find the path to the /// backing field that is accessed. /// </remarks> public virtual IEnumerator BackingFieldPath(IReflectClass claxx, object expression ) { return BackingFieldPath(claxx.GetName(), expression); }
private ClassMetadata ReadClassMetadata(IReflectClass reflectClazz) { ClassMetadata clazz = (ClassMetadata)_classMetadataByBytes.Remove(GetNameBytes(reflectClazz .GetName())); if (clazz == null) { return null; } return ReadClassMetadata(clazz, reflectClazz); }
public ObjectNotStorableException(IReflectClass clazz) : base(Messages .Get(clazz.IsImmutable() ? 59 : 45, clazz.GetName())) { }
private bool ShouldStoreTransientFields(IReflectClass claxx) { Config4Class configClass = _config.ConfigClass(claxx.GetName()); return configClass == null ? false : configClass.StoreTransientFields(); }
private IReflectClass NormalizeFieldClass(RawFieldSpec fieldInfo, IReflectClass fieldClass ) { // TODO: why the following line is necessary? IReflectClass theClass = _stream.Reflector().ForName(fieldClass.GetName()); if (fieldInfo.IsPrimitive()) { theClass = PrimitiveClass(theClass); } if (fieldInfo.IsArray()) { theClass = ArrayClass(theClass); } return theClass; }
internal ClassMetadata ClassMetadataForReflectClass(IReflectClass reflectClazz) { ClassMetadata cached = (ClassMetadata)_classMetadataByClass.Get(reflectClazz); if (cached != null) { return cached; } ClassMetadata byName = (ClassMetadata)_classMetadataByName.Get(reflectClazz.GetName ()); if (byName != null) { return byName; } return ReadClassMetadata(reflectClazz); }
public virtual void Register(IReflectClass clazz) { Register(clazz.GetName(), clazz); }
public ObjectNotStorableException(IReflectClass clazz) : base(Db4objects.Db4o.Internal.Messages .Get(clazz.IsSimple() ? 59 : 45, clazz.GetName())) { }