protected RootCacheValueFactoryDelegate CreateDelegate(IEntityMetaData metaData)
{
RootCacheValueFactoryDelegate rootCacheValueFactory;
Type enhancedType = null;
try
{
enhancedType = BytecodeEnhancer.GetEnhancedType(typeof(RootCacheValue), new RootCacheValueEnhancementHint(metaData.EntityType));
if (enhancedType == typeof(RootCacheValue))
{
// Nothing has been enhanced
rootCacheValueFactory = rcvFactory;
}
else
{
rootCacheValueFactory = AccessorTypeProvider.GetConstructorType <RootCacheValueFactoryDelegate>(enhancedType);
}
}
catch (Exception e)
{
if (Log.WarnEnabled)
{
Log.Warn(BytecodePrinter.ToPrintableBytecode(enhancedType), e);
}
// something serious happened during enhancement: continue with a fallback
rootCacheValueFactory = rcvFactory;
}
typeToConstructorMap.Put(metaData, rootCacheValueFactory);
return(rootCacheValueFactory);
}
public IEntityTypePrivilegeFactory GetEntityTypePrivilegeFactory(Type entityType, bool?create, bool?read, bool?update, bool?delete,
bool?execute)
{
if (BytecodeEnhancer == null)
{
return(ci);
}
int index = AbstractTypePrivilege.CalcIndex(create, read, update, delete, execute);
IEntityTypePrivilegeFactory[] factories = typeToConstructorMap.Get(entityType);
IEntityTypePrivilegeFactory factory = factories != null ? factories[index] : null;
if (factory != null)
{
return(factory);
}
Object writeLock = this.writeLock;
lock (writeLock)
{
// concurrent thread might have been faster
factories = typeToConstructorMap.Get(entityType);
factory = factories != null ? factories[index] : null;
if (factory != null)
{
return(factory);
}
try
{
Type enhancedType = BytecodeEnhancer.GetEnhancedType(typeof(AbstractTypePrivilege), new EntityTypePrivilegeEnhancementHint(entityType,
create, read, update, delete, execute));
if (enhancedType == typeof(AbstractTypePrivilege))
{
// Nothing has been enhanced
factory = ci;
}
else
{
factory = AccessorTypeProvider.GetConstructorType <IEntityTypePrivilegeFactory>(enhancedType);
}
}
catch (Exception e)
{
if (Log.WarnEnabled)
{
Log.Warn(e);
}
// something serious happened during enhancement: continue with a fallback
factory = ci;
}
if (factories == null)
{
factories = new IEntityTypePrivilegeFactory[AbstractTypePrivilege.ArraySizeForIndex()];
typeToConstructorMap.Put(entityType, factories);
}
factories[index] = factory;
return(factory);
}
}
/**
* {@inheritDoc}
*/
public Type GetImplementingType(Type keyType)
{
if (IsRegistered(keyType))
{
return(BytecodeEnhancer.GetEnhancedType(keyType, ImplementAbstractObjectEnhancementHint.INSTANCE));
}
throw new ArgumentException(keyType.FullName + " is not a registered type");
}
public Object CreateEmbeddedObject(Type embeddedType, Type entityType, Object parentObject, String memberPath)
{
Type enhancedEmbeddedType = BytecodeEnhancer.GetEnhancedType(embeddedType, new EmbeddedEnhancementHint(entityType, parentObject.GetType(),
memberPath));
ConstructorInfo embeddedConstructor = GetEmbeddedParamConstructor(enhancedEmbeddedType, parentObject.GetType());
Object[] constructorArgs = new Object[] { parentObject };
return(embeddedConstructor.Invoke(constructorArgs));
}
public void RefreshMembers(IEntityMetaData metaData)
{
if (metaData.EnhancedType == null)
{
((EntityMetaData)metaData).Initialize(CacheModification, EntityFactory);
IEntityInstantiationExtension eie = entityInstantiationExtensions.GetExtension(metaData.EntityType);
Type baseType = eie != null?eie.GetMappedEntityType(metaData.EntityType) : metaData.EntityType;
((EntityMetaData)metaData).EnhancedType = BytecodeEnhancer.GetEnhancedType(baseType, EntityEnhancementHint.Instance);
}
RelationMember[] relationMembers = metaData.RelationMembers;
for (int a = relationMembers.Length; a-- > 0;)
{
relationMembers[a] = (RelationMember)RefreshMember(metaData, relationMembers[a]);
}
PrimitiveMember[] primitiveMembers = metaData.PrimitiveMembers;
for (int a = primitiveMembers.Length; a-- > 0;)
{
primitiveMembers[a] = (PrimitiveMember)RefreshMember(metaData, primitiveMembers[a]);
}
HashMap <String, PrimitiveMember> nameToPrimitiveMember = new HashMap <String, PrimitiveMember>();
for (int a = primitiveMembers.Length; a-- > 0;)
{
PrimitiveMember member = primitiveMembers[a];
nameToPrimitiveMember.Put(member.Name, member);
}
PrimitiveMember[] alternateIdMembers = metaData.AlternateIdMembers;
for (int a = alternateIdMembers.Length; a-- > 0;)
{
alternateIdMembers[a] = (PrimitiveMember)RefreshMember(metaData, alternateIdMembers[a]);
}
((EntityMetaData)metaData).IdMember = RefreshDefinedBy((PrimitiveMember)RefreshMember(metaData, metaData.IdMember), nameToPrimitiveMember);
((EntityMetaData)metaData).VersionMember = RefreshDefinedBy((PrimitiveMember)RefreshMember(metaData, metaData.VersionMember), nameToPrimitiveMember);
((EntityMetaData)metaData).UpdatedByMember = GetIfExists(metaData.UpdatedByMember, nameToPrimitiveMember);
((EntityMetaData)metaData).UpdatedOnMember = GetIfExists(metaData.UpdatedOnMember, nameToPrimitiveMember);
((EntityMetaData)metaData).CreatedByMember = GetIfExists(metaData.CreatedByMember, nameToPrimitiveMember);
((EntityMetaData)metaData).CreatedOnMember = GetIfExists(metaData.CreatedOnMember, nameToPrimitiveMember);
for (int a = primitiveMembers.Length; a-- > 0;)
{
RefreshDefinedBy(primitiveMembers[a], nameToPrimitiveMember);
}
for (int a = alternateIdMembers.Length; a-- > 0;)
{
RefreshDefinedBy(alternateIdMembers[a], nameToPrimitiveMember);
}
UpdateEntityMetaDataWithLifecycleExtensions(metaData);
((EntityMetaData)metaData).Initialize(CacheModification, EntityFactory);
}
protected Type GetMemberTypeIntern(Type targetType, String propertyName, Type baseType)
{
String memberTypeName = targetType.Name + "$" + baseType.Name + "$" + propertyName.Replace('.', '$');
//if (memberTypeName.StartsWith("java."))
//{
// memberTypeName = "ambeth." + memberTypeName;
//}
if (baseType == typeof(RelationMember))
{
return(BytecodeEnhancer.GetEnhancedType(baseType, new RelationMemberEnhancementHint(targetType, propertyName)));
}
return(BytecodeEnhancer.GetEnhancedType(baseType, new MemberEnhancementHint(targetType, propertyName)));
}
protected IObjRefStoreFactory BuildDelegate(Type entityType, int idIndex)
{
lock (writeLock)
{
IObjRefStoreFactory objRefConstructorDelegate = constructorDelegateMap.Get(entityType, idIndex);
if (objRefConstructorDelegate != null)
{
return(objRefConstructorDelegate);
}
Type enhancedType = BytecodeEnhancer.GetEnhancedType(typeof(ObjRefStore), new ObjRefStoreEnhancementHint(entityType, idIndex));
objRefConstructorDelegate = AccessorTypeProvider.GetConstructorType <IObjRefStoreFactory>(enhancedType);
constructorDelegateMap.Put(entityType, idIndex, objRefConstructorDelegate);
return(objRefConstructorDelegate);
}
}
public PrimitiveMember CreateCompositeIdMember(Type entityType, PrimitiveMember[] idMembers)
{
if (BytecodeEnhancer == null)
{
throw new NotSupportedException("No bytecodeEnhancer specified");
}
StringBuilder nameSB = new StringBuilder();
// order does matter here
for (int a = 0, size = idMembers.Length; a < size; a++)
{
String name = idMembers[a].Name;
if (a > 0)
{
nameSB.Append('&');
}
nameSB.Append(name);
}
Type compositeIdType = BytecodeEnhancer.GetEnhancedType(typeof(Object), new CompositeIdEnhancementHint(idMembers));
return(new CompositeIdMember(entityType, compositeIdType, nameSB.ToString(), idMembers, MemberTypeProvider));
}
public override bool SupportsEnhancement(Type enhancementType)
{
return(BytecodeEnhancer.SupportsEnhancement(enhancementType));
}
public override IClassVisitor Extend(IClassVisitor visitor, IBytecodeBehaviorState state, IList <IBytecodeBehavior> remainingPendingBehaviors, IList <IBytecodeBehavior> cascadePendingBehaviors)
{
MemberEnhancementHint memberHint = state.GetContext <MemberEnhancementHint>();
if (memberHint == null)
{
return(visitor);
}
RelationMemberEnhancementHint relationMemberHint = state.GetContext <RelationMemberEnhancementHint>();
String[] memberNameSplit = EmbeddedMember.Split(memberHint.MemberName);
if (memberNameSplit.Length == 1)
{
IPropertyInfo[] sPropertyPath = new IPropertyInfo[1];
sPropertyPath[0] = PropertyInfoProvider.GetProperty(memberHint.DeclaringType, memberHint.MemberName);
visitor = new EntityMetaDataMemberVisitor(visitor, memberHint.DeclaringType, memberHint.DeclaringType, memberHint.MemberName,
EntityMetaDataProvider, sPropertyPath);
if (relationMemberHint != null)
{
visitor = new EntityMetaDataRelationMemberVisitor(visitor, memberHint.DeclaringType, memberHint.MemberName, sPropertyPath);
}
else
{
visitor = new EntityMetaDataPrimitiveMemberVisitor(visitor, memberHint.DeclaringType, memberHint.MemberName, sPropertyPath);
}
return(visitor);
}
Member[] members = new Member[memberNameSplit.Length];
Type currType = memberHint.DeclaringType;
IPropertyInfo[] propertyPath = new IPropertyInfo[members.Length];
StringBuilder sb = new StringBuilder();
for (int a = 0, size = memberNameSplit.Length; a < size; a++)
{
if (a + 1 < memberNameSplit.Length)
{
members[a] = MemberTypeProvider.GetMember(currType, memberNameSplit[a]);
}
else if (relationMemberHint != null)
{
members[a] = MemberTypeProvider.GetRelationMember(currType, memberNameSplit[a]);
}
else
{
members[a] = MemberTypeProvider.GetPrimitiveMember(currType, memberNameSplit[a]);
}
if (a > 0)
{
sb.Append('.');
}
sb.Append(members[a].Name);
propertyPath[a] = PropertyInfoProvider.GetProperty(currType, memberNameSplit[a]);
if (a + 1 < memberNameSplit.Length)
{
currType = BytecodeEnhancer.GetEnhancedType(members[a].RealType,
new EmbeddedEnhancementHint(memberHint.DeclaringType, currType, sb.ToString()));
}
else
{
currType = members[a].RealType;
}
}
visitor = new EntityMetaDataMemberVisitor(visitor, memberHint.DeclaringType, memberHint.DeclaringType, memberHint.MemberName,
EntityMetaDataProvider, propertyPath);
if (relationMemberHint != null)
{
visitor = new EntityMetaDataRelationMemberVisitor(visitor, memberHint.DeclaringType, memberHint.MemberName, propertyPath);
}
else
{
visitor = new EntityMetaDataPrimitiveMemberVisitor(visitor, memberHint.DeclaringType, memberHint.MemberName, propertyPath);
}
visitor = new EntityMetaDataEmbeddedMemberVisitor(visitor, memberHint.DeclaringType, memberHint.MemberName, members);
return(visitor);
}
