Don't know, but LOL.
This might be an instancing issue in which special handling is good for this
scenario but seems to be fine for most cases. And in a lazy TDD programming
way it might be good enough.

Although I know from blog and other threads that you look for greatness :-)
and not just code that works. Which is very inspiring now a days, in this
business hour of programming history.

I'll ask arround though, I think I might know someone who might know, and
also is not my mother...

f(t)

On Thu, Nov 20, 2008 at 6:26 PM, Nino Saturnino Martinez Vazquez Wael <
[EMAIL PROTECTED]> wrote:

> I love simple and simple is good. But this approach has issues with
> hibernate if your hibernate sessions are per request and your shadowmodel
> lives in multiple requests and your entities has references to other
> entities for example 1..* etc ...  In "simple" use cases, and possibly also
> when not using hibernate this might be fine. This is what I am exploring
> currently. When not attending seminars or talking with people..
>
> Im wondering how eclipselink & openJPA handles the "hibernate lazy load
> problem", according to a oracle guy theres not a problem when using Toplink
> (which now are eclipselink?)
>
> Input on these things are very welcome...
>
> regards Nino
>
>
> Francisco Diaz Trepat - gmail wrote:
>
>> why?
>> simple is good. doesn't need to be complex.
>>
>> what part you dislike the most?
>>
>> f(t)
>>
>> On Thu, Nov 20, 2008 at 2:29 AM, Nino Saturnino Martinez Vazquez Wael <
>> [EMAIL PROTECTED]> wrote:
>>
>>
>>
>>> BTW this is a flawed approch.. We need something a little more
>>> intelligent.. I'll return on the subject..
>>>
>>>
>>> Nino Saturnino Martinez Vazquez Wael wrote:
>>>
>>>
>>>
>>>> heres the raw and completely untested version of it. probably with a
>>>> whole
>>>> bunch of issues...:
>>>>
>>>>  package zeuzgroup.web.model;
>>>>    import java.lang.reflect.Field;
>>>>  import java.util.HashMap;
>>>>  import java.util.Map;
>>>>  import java.util.Map.Entry;
>>>>    import org.apache.wicket.Component;
>>>>  import org.apache.wicket.WicketRuntimeException;
>>>>  import org.apache.wicket.model.AbstractPropertyModel;
>>>>  import org.apache.wicket.model.CompoundPropertyModel;
>>>>  import org.apache.wicket.model.IModel;
>>>>  import org.apache.wicket.model.IWrapModel;
>>>>    public class EditorModel<T> extends CompoundPropertyModel<T> {
>>>>        private final Map<String, Object> newValues = new HashMap<String,
>>>> Object>();
>>>>        public EditorModel(IModel<T> underlyingModel) {
>>>>          super(underlyingModel);
>>>>      }
>>>>        public void fillOriginal() {
>>>>            Class<?> c = this.getObject().getClass();
>>>>            for (Entry<String, Object> entry : newValues.entrySet()) {
>>>>              try {
>>>>                  Field t = c.getDeclaredField(entry.getKey());
>>>>                  t.set(this.getObject(), entry.getValue());
>>>>              } catch (Exception e) {
>>>>                  throw new WicketRuntimeException("Could not set "
>>>>                          + entry.getKey(), e);
>>>>              }
>>>>            }
>>>>      }
>>>>        public <C> IWrapModel<C> wrapOnInheritance(Component component) {
>>>>          return new AttachedCompoundPropertyModel<C>(component,
>>>> newValues);
>>>>      }
>>>>        private class AttachedCompoundPropertyModel<C> extends
>>>>              AbstractPropertyModel<C> implements IWrapModel<C> {
>>>>          private static final long serialVersionUID = 1L;
>>>>            private final Component owner;
>>>>            private final Map<String, Object> newValues;
>>>>            /**
>>>>           * Constructor
>>>>           *
>>>>           * @param owner
>>>>           *            component that this model has been attached to
>>>>           */
>>>>          public AttachedCompoundPropertyModel(Component owner,
>>>> Map<String,Object> map) {
>>>>              super(EditorModel.this);
>>>>              this.owner = owner;
>>>>              this.newValues = map;
>>>>          }
>>>>            @Override
>>>>          public C getObject() {
>>>>              if (EditorModel.this.newValues.containsKey(owner.getId()))
>>>> {
>>>>                  return (C) newValues.get(owner.getId());
>>>>              } else {
>>>>                  return super.getObject();
>>>>              }
>>>>          }
>>>>            @Override
>>>>          public void setObject(C object) {
>>>>              newValues.put(owner.getId(), object);
>>>>          }
>>>>            /**
>>>>           * @see
>>>> org.apache.wicket.model.AbstractPropertyModel#propertyExpression()
>>>>           */
>>>>          @Override
>>>>          protected String propertyExpression() {
>>>>              return EditorModel.this.propertyExpression(owner);
>>>>          }
>>>>            /**
>>>>           * @see org.apache.wicket.model.IWrapModel#getWrappedModel()
>>>>           */
>>>>          public IModel<T> getWrappedModel() {
>>>>              return EditorModel.this;
>>>>          }
>>>>            /**
>>>>           * @see org.apache.wicket.model.AbstractPropertyModel#detach()
>>>>           */
>>>>          @Override
>>>>          public void detach() {
>>>>              super.detach();
>>>>              EditorModel.this.detach();
>>>>          }
>>>>      }
>>>>    }
>>>>    // IComponentAssignedModel / IWrapModel
>>>>
>>>> Francisco Diaz Trepat - gmail wrote:
>>>>
>>>>
>>>>
>>>>> Nice, I was up to something similar.
>>>>>
>>>>> On Tue, Nov 18, 2008 at 9:43 AM, Nino Saturnino Martinez Vazquez Wael <
>>>>> [EMAIL PROTECTED]> wrote:
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>> Hi
>>>>>>
>>>>>> Im trying todo a compoundpropertymodel which does not change original
>>>>>> values in the "original" model. I need this since I am updating some
>>>>>> stuff
>>>>>> in a wizard but I first want to commit when the user confirms in the
>>>>>> end
>>>>>> of
>>>>>> the wizard, and if the model are changed directly the transaction are
>>>>>> automatically committed to the database....
>>>>>>
>>>>>> So my idea were to todo a shadowCompoundPropertyModel something like
>>>>>> this:
>>>>>>
>>>>>> class EditorModel extends CompoundPropertyModel {
>>>>>>
>>>>>>  private Map newValues=new HashMap<String, Object>();
>>>>>>   public EditorModel(CompoundPropertyModel underlyingModel,
>>>>>>         String propertyName) {
>>>>>>     super(underlyingModel);
>>>>>>  }
>>>>>>  public getObject (String property){
>>>>>> check if there are something in the map if so return it, otherwise
>>>>>> fall
>>>>>> back to the underlying model
>>>>>>
>>>>>> }  public setObject (String prop, Value){
>>>>>>  put changes in the map...
>>>>>> }
>>>>>>
>>>>>> public UpdateOriginal(){
>>>>>> iterate over the map and use reflection to set values on the original
>>>>>> model..
>>>>>>
>>>>>> }
>>>>>>
>>>>>> }
>>>>>>
>>>>>> Does anybody have something similar floating around, in a more
>>>>>> complete
>>>>>> state..? Or could it be done in a easier way?
>>>>>>
>>>>>> --
>>>>>> -Wicket for love
>>>>>>
>>>>>> Nino Martinez Wael
>>>>>> Java Specialist @ Jayway DK
>>>>>> http://www.jayway.dk
>>>>>> +45 2936 7684
>>>>>>
>>>>>>
>>>>>> ---------------------------------------------------------------------
>>>>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>>>>> For additional commands, e-mail: [EMAIL PROTECTED]
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>> --
>>> -Wicket for love
>>>
>>> Nino Martinez Wael
>>> Java Specialist @ Jayway DK
>>> http://www.jayway.dk
>>> +45 2936 7684
>>>
>>>
>>> ---------------------------------------------------------------------
>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>> For additional commands, e-mail: [EMAIL PROTECTED]
>>>
>>>
>>>
>>>
>>
>>
>>
>
> --
> -Wicket for love
>
> Nino Martinez Wael
> Java Specialist @ Jayway DK
> http://www.jayway.dk
> +45 2936 7684
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [EMAIL PROTECTED]
> For additional commands, e-mail: [EMAIL PROTECTED]
>
>

Reply via email to