001    package railo.runtime.orm.hibernate.tuplizer;
002    
003    import java.io.Serializable;
004    import java.util.HashMap;
005    
006    import org.hibernate.EntityMode;
007    import org.hibernate.EntityNameResolver;
008    import org.hibernate.HibernateException;
009    import org.hibernate.engine.SessionFactoryImplementor;
010    import org.hibernate.engine.SessionImplementor;
011    import org.hibernate.mapping.PersistentClass;
012    import org.hibernate.mapping.Property;
013    import org.hibernate.property.Getter;
014    import org.hibernate.property.PropertyAccessor;
015    import org.hibernate.property.Setter;
016    import org.hibernate.proxy.ProxyFactory;
017    import org.hibernate.tuple.Instantiator;
018    import org.hibernate.tuple.entity.AbstractEntityTuplizer;
019    import org.hibernate.tuple.entity.EntityMetamodel;
020    
021    import railo.runtime.Component;
022    import railo.runtime.ComponentScope;
023    import railo.runtime.op.Caster;
024    import railo.runtime.orm.hibernate.tuplizer.accessors.CFCAccessor;
025    import railo.runtime.orm.hibernate.tuplizer.proxy.CFCProxyFactory;
026    import railo.runtime.type.KeyImpl;
027    import railo.runtime.type.cfc.ComponentAccess;
028    import railo.runtime.type.util.ComponentUtil;
029    
030    public class AbstractEntityTuplizerImpl extends AbstractEntityTuplizer {
031    
032            private static CFCAccessor accessor=new CFCAccessor();
033            
034            public AbstractEntityTuplizerImpl(EntityMetamodel entityMetamodel, PersistentClass persistentClass) {
035                    super(entityMetamodel, persistentClass);
036            }
037    
038            @Override
039            public Serializable getIdentifier(Object entity, SessionImplementor arg1) {
040                    return toIdentifier(super.getIdentifier(entity, arg1));
041            }
042            
043            @Override
044            public Serializable getIdentifier(Object entity) throws HibernateException {
045                    return toIdentifier(super.getIdentifier(entity));
046            }
047    
048            private Serializable toIdentifier(Serializable id) {
049                    if(id instanceof Component) {
050                            HashMap<String, String> map = new HashMap<String, String>();
051                            Component cfc=(Component) id;
052                            ComponentScope scope = cfc.getComponentScope();
053                            railo.runtime.component.Property[] props = ComponentUtil.getIDProperties(cfc, true,true);
054                            String name,value;
055                            for(int i=0;i<props.length;i++){
056                                    name=props[i].getName();
057                                    value=Caster.toString(scope.get(KeyImpl.init(name),null),null);
058                                    map.put(name, value);
059                            }
060                            return map;
061                    }
062                    return id;
063            }
064    
065    
066            @Override
067            protected Instantiator buildInstantiator(PersistentClass persistentClass) {
068                    return new CFCInstantiator(persistentClass);
069            }
070            
071            /**
072             * return accessors 
073             * @param mappedProperty
074             * @return
075             */
076            private PropertyAccessor buildPropertyAccessor(Property mappedProperty) {
077                    if ( mappedProperty.isBackRef() ) {
078                            PropertyAccessor ac = mappedProperty.getPropertyAccessor(null);
079                            if(ac!=null) return ac;
080                    }
081                    return accessor;
082            }
083    
084            
085            @Override
086            protected Getter buildPropertyGetter(Property mappedProperty, PersistentClass mappedEntity) {
087                    return buildPropertyAccessor(mappedProperty).getGetter( null, mappedProperty.getName() );
088            }
089    
090            
091            @Override
092            protected Setter buildPropertySetter(Property mappedProperty, PersistentClass mappedEntity) {
093                    return buildPropertyAccessor(mappedProperty).getSetter( null, mappedProperty.getName() );
094            }
095            
096            @Override
097            protected ProxyFactory buildProxyFactory(PersistentClass pc, Getter arg1,Setter arg2) {
098                    CFCProxyFactory pf = new CFCProxyFactory();
099                    pf.postInstantiate(pc);
100                    
101                    return pf;
102            }
103    
104            @Override
105            public String determineConcreteSubclassEntityName(Object entityInstance, SessionFactoryImplementor factory) {
106                    return CFCEntityNameResolver.INSTANCE.resolveEntityName(entityInstance);
107            }
108    
109            @Override
110            public EntityNameResolver[] getEntityNameResolvers() {
111                    return new EntityNameResolver[] { CFCEntityNameResolver.INSTANCE };
112            }
113    
114            @Override
115            public Class getConcreteProxyClass() {
116                    return ComponentAccess.class;// ????
117            }
118    
119            @Override
120            public Class getMappedClass() {
121                    return ComponentAccess.class; // ????
122            }
123    
124            public EntityMode getEntityMode() {
125                    return EntityMode.MAP;
126            }
127    
128            @Override
129            public boolean isInstrumented() {
130                    return false;
131            }
132    
133    }