/sigh

[syntaxeater]

Stuff and things... The coding I need to get done now (the 3 tasks) gets locked down on Friday for testing. I was going to use all of Thursday for testing the applications that have gone live, but now it lookw like I'll use all of Thursday night for that instead.

I coded myself into a circle. One of the things I was working on didn't turn out right (not without breaking people in the process anyway). So I tried something else that will work, but didn't completely phase out the stuff I added from the first attempt.

In a nutshell:
It was some screwed up stuff that had to do with some of my objects sharing their reference-type objects, but also having the functionality to create their own instance of that type of object for their own use. In which case, the objects with their own instance (which are not known ahead of time) will merge with what they would have pointed to during runtime. All the while the location (index, not memory location) each of these objects are pointed (and even which of the objects to point) to changes based on the settings the developer gives my object (also not known until runtime). So the objects that created their own instance need to retain and apply what they have been given and know which object to merge with at runtime (assuming the location of its referenced object had not been lost when it made its own - what it would have pointed to).

So to take into account what I don't know:
1 - How many of my objects are being used by the developer.
2 - If my object they are using will have its own instance of the object type all the others are referencing.
3 - Which object they will be or are supposed to be referencing at runtime (the index of and changes to the object they using all happen after the object is created during runtime).
4 - If and which of my objects will be consumed by other instances of the same type of object (they are capable of merging with eachother and appear as one object to the developer using them, but still need to retain their individuality behind the scenes since they are capable of referencing (or having) their own object and should only modify it for other unknown objects that may also be referencing it).
5 - The dimensions of my object (It works like an elastic grid. It grows and shrinks depending on the size of the object it is referencing and also the number of seperate instances being referenced).
6 - The types of objects it will reference. All of this is being done through generic type handlers. Everything from adding, removing, inserting, replacing or modifying is all handled through predicates. At design time, I know what types I can expect to receive but not which ones will be invoked. So by extension...
7 - The methods that will be called.

And if all of this wasn't insane enough to deal with... Next week I get to build the test harness. /wrist