public boolean isInstance(Object object) {
      if (isDynamic) {
         return (object instanceof Map) &&
            entityName.equals( ( (Map) object ).get("type") );
      }
      else {
         return mappedClass.isInstance(object);
      }
   }

public class MetaObjectAccessor implements PropertyAccessor {

    static final Log log = Log.getLog( MetaObjectAccessor.class );

    /**
     * Creates a Getter for this named attribute.
     */
    public Getter getGetter( Class theClass, String propertyName ) throws PropertyNotFoundException
    {
        return new MetaObjectGetter( propertyName );
    }

    /**
     * Creates a Setter for this named attribute
     */
    public Setter getSetter( Class theClass, String propertyName ) throws PropertyNotFoundException
    {
        return new MetaObjectSetter( propertyName );
    }

    private final class MetaObjectSetter implements Setter {

        private String propertyName;

        public MetaObjectSetter( String propertyName )
        {
            this.propertyName = propertyName;
        }

        public void set( Object target, Object value ) throws HibernateException
        {
            if ( target != null && target instanceof MetaObject )
                {
                MetaObject metaObject = ( MetaObject ) target;
                if ( log.isDebugEnabled() )
                    log.debug( "Setting field [" + propertyName + "] to " + value );

                metaObject.setProperty( propertyName, value );
                }
        }

        public String getMethodName()
        {
            return null;
        }

        public Method getMethod()
        {
            return null;
        }
    }

    private final class MetaObjectGetter implements Getter {

        private String propertyName;

        public MetaObjectGetter( String propertyName )
        {
            this.propertyName = propertyName;
        }

        public Object get( Object target ) throws HibernateException
        {
            if ( target != null && target instanceof MetaObject )
                {
                MetaObject metaObject = ( MetaObject ) target;
                return metaObject.getProperty( propertyName );
                }

            return null;
        }

        public Class getReturnType()
        {
            return Object.class;
        }

        public String getMethodName()
        {
            return null;
        }

        public Method getMethod()
        {
            return null;
        }
    }

}

/**
* An interceptor that allows Hibernate to create MetaObjects when loading
* data from the database.
*
*/
public class MetaObjectInterceptor implements Interceptor {

    static Log log = Log.getLog( MetaObjectInterceptor.class );

    private MetaKit metaKit;

    /**
     * Creates a new MetaObjectInterceptor that will use a MapMetaKit
     * as its underlying meta-object implementation layer.
     */
    public MetaObjectInterceptor()
    {
        this( new MapMetaKit( null ) );
    }

    /**
     * Creates a new MetaObjectInterceptor that will use the specified
     * MetaKit as its underlying meta-object implementation layer.
     */
    public MetaObjectInterceptor( MetaKit metaKit )
    {
        this.metaKit = metaKit;
    }

    /**
     * Creates an instance of a MetaObject with a given name.
     */
    public Object instantiate( String entityName, Serializable serializable ) throws CallbackException
    {
        MetaClass metaClass = MetaClass.forName( entityName );
        MetaObjectFactory factory = metaKit.getMetaObjectFactory();
        MetaObject metaObject = factory.createMetaObject( metaClass );

        // FIXME:
        // Until Hibernate fixes the Interceptor interface to include the EntityPersister
        // in the instantiate method, we need depend on the identity field in the meta
        // configuration
        Set identityProperties = metaObject.getMetaClass().getIdentityProperties();
        if( identityProperties.size() == 0 )
            {
            log.warn( "No identifiers defined for this metaClass [" + entityName + "]" );
            }

        if( identityProperties.size() == 1 )
            {
            String identityProperty = ( String ) identityProperties.toArray()[0];
            metaObject.setProperty(identityProperty , serializable );
            }

        if( identityProperties.size() > 1 )
            {
            log.warn( "Multiple identity properties defined for metaClass [" + entityName + "]" );
            }

        return metaObject;
    }

    /**
     * Returns the entityName of this object (type attribute's value).
     */
    public String getEntityName( Object o ) throws CallbackException
    {
        MetaObject metaObject = ( MetaObject ) o;
        return metaObject.getMetaClass().getName();
    }

    public boolean onLoad( Object o, Serializable serializable, Object[] objects, String[] strings, Type[] types ) throws CallbackException
    {
        return false;
    }

    public boolean onFlushDirty( Object o, Serializable serializable, Object[] objects, Object[] objects1, String[] strings, Type[] types ) throws CallbackException
    {
        return false;
    }

    public boolean onSave( Object o, Serializable serializable, Object[] objects, String[] strings, Type[] types ) throws CallbackException
    {
        return false;
    }

    public void onDelete( Object o, Serializable serializable, Object[] objects, String[] strings, Type[] types ) throws CallbackException
    {

    }

    public void preFlush( Iterator iterator ) throws CallbackException
    {

    }

    public void postFlush( Iterator iterator ) throws CallbackException
    {

    }

    public Boolean isUnsaved( Object o )
    {
        return null;
    }

    public int[] findDirty( Object o, Serializable serializable, Object[] objects, Object[] objects1, String[] strings, Type[] types )
    {
        return new int[0];
    }

    public Object getEntity( String s, Serializable serializable ) throws CallbackException
    {
        return null;
    }

}

Query query = session.createQuery( "from person" );
Iterator results = query.iterate();
while ( results.hasNext() )
   {
        log.info( results.next() );
        }

query = session.createQuery( "from person" );
List resultsList = query.list();
for ( Iterator iterator = resultsList.iterator(); iterator.hasNext(); )
   {
        log.info( iterator.next() );
        }

public class SimpleMetaObjectPersister extends SingleTableEntityPersister
{
    static Log log = Log.getLog( SimpleMetaObjectPersister.class );

    public SimpleMetaObjectPersister( PersistentClass persistentClass,
                                      CacheConcurrencyStrategy cacheStrategy,
                                      SessionFactoryImplementor factory )
    {
        super( persistentClass, cacheStrategy, factory );
    }

    public boolean isInstance( Object object )
    {
        MetaObject metaObject = ( MetaObject ) object;
        return metaObject.getMetaClass().getName().equals( getEntityName() );
    }
}