private bool IsTAAware(ClassMetadata classMetadata)
{
GenericReflector reflector = classMetadata.Reflector();
return(reflector.ForClass(typeof(IActivatable)).IsAssignableFrom(classMetadata.ClassReflector
()));
}
private GenericField[] Fields(GenericClass personClass, GenericReflector reflector
)
{
return(new GenericField[] { new GenericField("surname", reflector.ForClass(typeof(
string)), false), new GenericField("birthdate", reflector.ForClass(typeof(DateTime
)), false), new GenericField("bestFriend", personClass, false), new GenericField
("nArray", reflector.ForClass(typeof(int[][])), true) });
}
public IType GetFieldType()
{
GenericReflector reflecotr = objectContainer.Ext().Reflector();
IReflectClass klass = reflecotr.ForName(m_classname);
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(klass, m_fieldname);
return(Db4oClient.TypeResolver.Resolve(rfield.GetFieldType()));
}
private void RegisterTypeHandler(IConfiguration config, Type clazz, ITypeHandler4
typeHandler)
{
GenericReflector reflector = ((Config4Impl)config).Reflector();
IReflectClass itemClass = reflector.ForClass(clazz);
ITypeHandlerPredicate predicate = new _ITypeHandlerPredicate_229(itemClass);
config.RegisterTypeHandler(predicate, typeHandler);
}
/// <summary>todo: Move the GenericClass creation into a utility/factory class.</summary>
/// <remarks>todo: Move the GenericClass creation into a utility/factory class.</remarks>
/// <returns></returns>
public virtual GenericClass InitGenericClass()
{
GenericReflector reflector = new GenericReflector(null, Platform4.ReflectorForType
(typeof(GenericObjectsTest)));
GenericClass _objectIClass = (GenericClass)reflector.ForClass(typeof(object));
GenericClass result = new GenericClass(reflector, null, PersonClassname, _objectIClass
);
result.InitFields(Fields(result, reflector));
return(result);
}
private void InitClassReflectors(GenericReflector reflector)
{
IclassCompare = reflector.ForClass(Const4.ClassCompare);
IclassDb4otype = reflector.ForClass(Const4.ClassDb4otype);
IclassDb4otypeimpl = reflector.ForClass(Const4.ClassDb4otypeimpl);
IclassInternal = reflector.ForClass(Const4.ClassInternal);
IclassUnversioned = reflector.ForClass(Const4.ClassUnversioned);
IclassObject = reflector.ForClass(Const4.ClassObject);
IclassObjectcontainer = reflector.ForClass(Const4.ClassObjectcontainer);
IclassStaticclass = reflector.ForClass(Const4.ClassStaticclass);
IclassString = reflector.ForClass(typeof(string));
IclassTransientclass = reflector.ForClass(Const4.ClassTransientclass);
Platform4.RegisterCollections(reflector);
}
public virtual GenericClass ClassMetaToGenericClass(GenericReflector reflector, ClassInfo
classMeta)
{
if (classMeta.IsSystemClass())
{
return((GenericClass)reflector.ForName(classMeta.GetClassName()));
}
var className = classMeta.GetClassName();
// look up from generic class table.
var genericClass = LookupGenericClass(className);
if (genericClass != null)
{
return(genericClass);
}
var reflectClass = reflector.ForName(className);
if (reflectClass != null)
{
return((GenericClass)reflectClass);
}
GenericClass genericSuperClass = null;
var superClassMeta = classMeta.GetSuperClass();
if (superClassMeta != null)
{
genericSuperClass = ClassMetaToGenericClass(reflector, superClassMeta);
}
genericClass = new GenericClass(reflector, null, className, genericSuperClass);
RegisterGenericClass(className, genericClass);
var fields = classMeta.GetFields();
var genericFields = new GenericField[fields.Length];
for (var i = 0; i < fields.Length; ++i)
{
var fieldClassMeta = fields[i].GetFieldClass();
var fieldName = fields[i].GetFieldName();
var genericFieldClass = ClassMetaToGenericClass(reflector, fieldClassMeta
);
genericFields[i] = new GenericField(fieldName, genericFieldClass, fields[i]._isPrimitive
);
}
genericClass.InitFields(genericFields);
return(genericClass);
}
public ReplicationReflector(IReplicationProvider providerA, IReplicationProvider
providerB, IReflector reflector)
{
if (reflector == null)
{
if ((_container = ContainerFrom(providerA)) != null)
{
return;
}
if ((_container = ContainerFrom(providerB)) != null)
{
return;
}
}
GenericReflector genericReflector = new GenericReflector(null, reflector == null ?
Platform4.ReflectorForType(typeof(Db4objects.Drs.Inside.ReplicationReflector)) :
reflector);
Platform4.RegisterCollections(genericReflector);
_reflector = genericReflector;
}
public GenericReflector Reflector()
{
GenericReflector reflector = (GenericReflector)_config.Get(ReflectorKey);
if (reflector == null)
{
IReflector configuredReflector = (IReflector)_config.Get(ConfiguredReflectorKey);
if (configuredReflector == null)
{
configuredReflector = Platform4.CreateReflector(ClassLoader());
_config.Put(ConfiguredReflectorKey, configuredReflector);
}
reflector = new GenericReflector(configuredReflector);
_config.Put(ReflectorKey, reflector);
}
// TODO: transaction assignment has been moved to YapStreamBase#initialize1().
// implement better, more generic solution as described in COR-288
// if(! reflector.hasTransaction() && i_stream != null){
// reflector.setTransaction(i_stream.getSystemTransaction());
// }
return(reflector);
}
internal HandlerRegistry(ObjectContainerBase container, byte stringEncoding, GenericReflector
reflector)
{
// this is the master container and not valid
// for TransportObjectContainer
_handlerVersions = new HandlerVersionRegistry(this);
_stringIO = BuiltInStringEncoding.StringIoForEncoding(stringEncoding, container.ConfigImpl
.StringEncoding());
_container = container;
container._handlers = this;
_reflector = reflector;
_diagnosticProcessor = container.ConfigImpl.DiagnosticProcessor();
InitClassReflectors(reflector);
_indexes = new SharedIndexedFields();
_virtualFields[0] = _indexes._version;
_virtualFields[1] = _indexes._uUID;
_virtualFields[2] = _indexes._commitTimestamp;
RegisterBuiltinHandlers();
RegisterPlatformTypes();
InitArrayHandlers();
Platform4.RegisterPlatformHandlers(container);
}
public GenericArrayReflector(GenericReflector reflector)
{
_delegate = reflector.GetDelegate().Array();
}
public static void RegisterCollections(GenericReflector reflector)
{
// reflector.RegisterCollectionUpdateDepth(
// typeof(IDictionary),
// 3);
}
public GenericArrayClass(GenericReflector reflector, IReflectClass delegateClass,
string name, GenericClass superclass) : base(reflector, delegateClass, name, superclass
)
{
}
public GenericArrayClass(GenericReflector reflector, IReflectClass delegateClass,
string name, GenericClass superclass) : base(reflector, delegateClass, name, superclass
)
{
}
public GenericClassBuilder(GenericReflector reflector, IReflector delegate_)
{
_reflector = reflector;
_delegate = delegate_;
}
public GenericClassBuilder(GenericReflector reflector, IReflector delegate_)
{
_reflector = reflector;
_delegate = delegate_;
}
public GenericArrayReflector(GenericReflector reflector)
{
_delegate = reflector.GetDelegate().Array();
}
