cindy | flexible Ruby SDK for Sendy , a self-hosted email | Email library

You can think of LinkingObjects almost as a computed property - it automagically creates an inverse link to the parent object when the child object is added to the parent objects List.

So when a Dog is added to a person's dogs list, a person reference is added to the Dog's walkers list. Keeping in mind that it's a many to many relationship so technically if Person A adds Doggo, and Person B adds Doggo, the Doggo's inverse relationship 'walkers' will contain Person A and Person B

the app still can run normally without any diff

Which is true, it doesn't affect he operation of the app. HOWEVER the difference is that by removing the walkers LinkingObjects, there's no way to query Dogs for their Person and get Dog Results (i.e. you can't traverse the graph of the relationship back to the person)

In other words we can query Person for kinds of dog stuff

You can use the ItemCountAware interface for that. This interface is to implement by your domain object (which seems to be Customer in your case) and will be called at reading time by any reader that extends AbstractItemCountingItemStreamItemReader.

So if your reader is one them, you can get the item count on your items and use it as needed in your LineAggregator.

EDIT: add option when the reader does not extend AbstractItemCountingItemStreamItemReader

You can always assign the item number in a ItemReadListener#afterRead and use that in your aggregator, something like:

Try this:

Good news/Bad news...

There is still a little meat left on the bone there that you could trim. You have several loops that are generating redundant elements. The bad news is that the solver usually can detect these and will weed them out, so you may not get much acceleration by trimming them.

3 things...

1. Your constraint that a player must have n_games is redundant because your next constraint forces them to have a game in each round
2. When you are creating your player - pplayer constraints, you are creating many duplicates because you are implicitly ordering p and pp. If the set P has 16 players, then the nested loop will create p*(p-1) constraints of each type, when ignoring p=pp. However, note that there are only C(16,2) logical constraints which is p*(p-1)/2.
3. You are doing similar thing when creating your set of legal games because you are implicitly ordering the legal teams.

Below is a tweaked version of your program.... It is still churning on my machine, so I don't know if any time will be saved. Your other "easy" options are to tinker with an optimality gap or a timeout.

I'll stew on this a bit more... but I'm not sure if there is another novel approach to this.

It is necessary to create the directory structure sequentially, by levels:

You can override the shape's style using a mui global class selectors:

You could convert the dictionary to a CSV file, which would give you the desired output.

• $setUnion to get unique elements from children.name and this will sort string in ascending order
• $concat to pass first parameter as $$value and second as condition if value is empty then return empty otherwise ", " and third as $$this means current string

When you first created the object { name:'Pete' }, you assigned it to a, i.e. a is pointing at that object in memory.

You then assigned the a to b, but you are really assigning the object pointed to by a to b, so now b points to that same memory location which contains the same object.

By assigning the empty object literal to a, you have created a new object and a is now pointing to it.

The old object {name: "Cindy", age: 20} still exists, and b is still pointing to it. b does not change because a no longer points at the same object.