Actually, upon sending, I was thinking, that what could be beneficial is a context of mementofication. Basically an argument context that could be used as it passes through all relationships, etc. It could be useful to use it as a traversal or visitor pattern. Where as the relationships are visited, the context can change or augment behavior. Why don’t we investigate this pattern @Jon Clausen https://sourcemaking.com/design_patterns/visitor

We could do an argument passthrough, but that would required that it goes to ALL getters. If that’s the case, we can do that and make it pretty simple like:

getMemento( args

Or something along those lines

I think the aliasing in https://ortussolutions.atlassian.net/browse/BOX-103 will solve the use case for this argument. Let’s just go with that and we can avoid this.

FWIW, though, we invoke the getters without any arguments, anyway. Passing in a boolean named argument doesn’t seem like it would really create any problems. If those getters have other arguments that are required, mementifier would blow up when invoking the getter anyway.

Few observations:

If you pass an argument like asmemento, you have to pass it to ALL getters. You can’t pick and choose how one relationship behaves and the other doesn’t. There has to be uniformity. If not you end up with more arguments to determine to which relationships you pass that argument too and to which ones you don’t. Plus how do you deal with recursion? You have to respect as you go deeper into the rabbit hole.

Secondly, If you don’t want to get the object graph you can always return an array of struct or a struct and mementifier respects that type and doesn’t process it. So essentially you can do this already by just returning and array of structs with projections like you mention in your example already. If you do that, mementifier determines the array is an array of structs and just sticks it into the result map.

This kind of ties in with the aliasing story and some of the problems could be solved by implementing that, but it allows a getter to be overloaded or customized and, if the asMemento argument flag is up, it would allow that getter to customize the return ( e.g. rather than returning object relationships, which need to go through their component lifecycles, return a projection list of just the data that the memento requires. )

The best example of this would be an ORM application with a large number of relationships which would be loaded by calling the getter.

If asMemento were passed, it could switch to providing a “lean” version of the data for that purpose: