Dynamic Array of Objects - mobj - an Abstraction

I'm working on an abstraction to create an array of objects that can be expanded or contracted on the fly. I call it "mobj" (multi-object, or, if you like, mob of objects). It's meant for you to have the patch saved in with the patch you want to use it in, then create an instance of it. If instantiated properly, you can treat the mobj just like you would treat the object that it is an array of, provided you prepend all input messages with a number from 0 to n-1 (which is treated like an index into the virtual array to route the input to the proper instance in the array) and acknowledge that all output messages will have the same prepended index.

This functionality is achieved by creating/deleting/patching the array of objects with scripting messages to a thispatcher object.

And the arguments for instantiation:

The first argument when you create an instance of the abstraction is the number of inlets for the mobj. This is meant to match the number of inlets of the type of object you want to create.

The second argument is the number of outlets of the mobj. Same idea, you match it to the number of outlets on the type of object in the array.

The third argument is the number of objects in the array.

The fourth argument is the name to use when creating objects, and all subsequent arguments will be the arguments of the objects created.

For example, you could create an array of 8 [line 0. 10] objects with:
[mobj 3 2 8 line 0. 10]

To change the number of objects in the array on the fly, simply pass any inlet of the object the message (num $1) or (number $1), and the correct number of objects is added or subtracted from the array. To change the number of inlets of the mobj. pass the message (inlets $1). All inlets are automatically routed to the corresponding inlet of each object in the array, provided that the object has enough inlets (if it doesn't, the inlet isn't routed to anything). The number of outlets can be changed in the same way (outlets $1). You can also change the objects themselves on the fly if you have the need, by passing (obj $1 $2 $3 ... $n) or (object $1 $2 $3 ... $n), in which $1 is the object name and all following terms are arguments to the object. Note that these object creation parameters will only apply to all subsequent objects that are created by sending a (num $1) increase message. Note that this means the array can actually contain different kinds of objects, or objects with different arguments. If you wish for all of the array objects to be recreated with the type you specify with (obj $1 $2 $3 ... $n), all you have to do is pass a (remake) message and all array objects will be deleted and remade.

- - -

So far, all of this is working properly, but there is one hitch: when you save and reload a patch using these mobj, all patch cords to and from the mobj are not recreated on reload. This is because each mobj begins with no inlets or outlets, then creates them as prompted by the patcherargs object in the mobj, and the parent patch always tries to create the patch connections before the inlets actually exist. So, as of right now, mobj only works if you connect up the inputs and outputs every time you load up a patch. I would love to hear some possible solutions to this problem, because right now, I am getting discouraged.

Here is the code. Save it in a folder as mobj.maxpat along with a new patch to use it in and see what I mean.

When mobj is done and working well, it's going to do so much for my Max workflow. I hope it can be of some use to others as well.