dynamically creating an deleting max objects

so this is the method to generate the hardwired routing: (just in case someone's interested in reading some code)

private void UpdateMixerMatrixPatcher()
{
  var aParentPatcher = this.ParentPatcher;
  var aMixerMatrixPatcher = aParentPatcher
    .GetSubPatcher("MixerMatrixPatcher");
  var aObjPrefix = "MixerMatrixObj";
  var aGetDynObjName = new Func<string, int, string>
    (delegate (string aPrefix, int aNamedObjIdx)
  {
    return aPrefix + "[" + aNamedObjIdx + "]";
  });
  var aGetStaticObjName = new Func<string, int, string>
    (delegate (string aPrefix, int aNamedObjIdx)
  {
    return aGetDynObjName(aPrefix, aNamedObjIdx);
  });
  { // DeleteOldObjects
    var aDone = false;
    for (var aObjIdx = 0; !aDone;++aObjIdx)
    {
        var aName = aGetDynObjName(aObjPrefix, aObjIdx);
        if (aMixerMatrixPatcher.GetContainsObject(aName))
        {
          var aObj = aMixerMatrixPatcher.GetBox(aName);
          aObj.Delete();
        }
        else
        {
          aDone = true;
        }
    }
  }

  { // AddNewObjects
    var aObjIdx = 0;
    var aGenObjectName = new Func<string>(() =>
    {
        var aName = aGetDynObjName(aObjPrefix, aObjIdx);
        ++aObjIdx;
        return aName;
    });
    var aCsState = this.CsState;
    var aFlowMatrix = aCsState.FlowMatrix;
    var aChannels = aFlowMatrix.Channels;
    var aIoCount = this.IoCount;
    var aMainIn = aMixerMatrixPatcher.GetBox("MainIn");
    var aMainOut = aMixerMatrixPatcher.GetBox("MainOut");
    var aOutputs = new CPatBox[aIoCount];
    for(var aOuputIdx = 0; aOuputIdx < aIoCount; ++aOuputIdx)
    {
        var aVstOutName = aGetStaticObjName("VstOut", aOuputIdx);
        var aVstOutObj = aMixerMatrixPatcher.GetBox(aVstOutName);
        aOutputs[aOuputIdx] = aVstOutObj;
    }
    var aInputs = new CPatBox[aIoCount];
    for (var aInputIdx = 0; aInputIdx < aIoCount; ++aInputIdx)
    {
        var aVstInName = aGetStaticObjName("VstIn", aInputIdx);
        var aVstInObj = aMixerMatrixPatcher.GetBox(aVstInName);
        aInputs[aInputIdx] = aVstInObj;
    }
    var aAddDelay = new Func<int, int, CPatBox>(delegate
      (int aDelayChannelIdx, int aDelayTime)
    {
        var aInput = aInputs[aDelayChannelIdx]; 
        var aSkipDelayIsAllowed = false; // can not delete cable 0->0 atm...
        if (aDelayTime == 0
        && aSkipDelayIsAllowed)
        {                  
          return aInput;
        }
        else
        {
          var aArgs = "" + aDelayTime + " " + aDelayTime;
          var aObjectName = aGenObjectName();
          var aBoxText = "mc.delay~ " + aDelayTime + " " + aDelayTime;
          var aDelay = aMixerMatrixPatcher.Add(aBoxText, aObjectName);
          aDelay.Outlets[0].ConnectTo(aInput.Inlets[0]);
          return aDelay;
        }
    });

    for(var aChannelIdx = 0; aChannelIdx < aIoCount; ++aChannelIdx)
    {
        var aChannel = aChannels.Channels[aChannelIdx];
        var aInputObj = aChannelIdx == 0
                      ? aMainIn
                      : aOutputs[aChannelIdx];
        foreach (var aOutputChannel in aChannel.OutputsWithoutMainOut)
        {
          var aInputChannelIdx = aOutputChannel.Inputs.IndexOf(aChannel);
          var aLatencyCompensation = aOutputChannel
            .LatencyCompensations[aInputChannelIdx];
          var aTargetInput = aAddDelay
            (aOutputChannel.IoIdx, aLatencyCompensation);
          aInputObj.Outlets[0].ConnectTo(aTargetInput.Inlets[0]);
        }
    }
  }
}

"When you are coding in C/C++ pretty much everything is open."

i still dont get it.

when you coding an external in C++ you have exactly the same possibilties as the developer of the vanilla externals, and when you run that external in max, then this custom external has the same possibilties than every other external, isnt it?

for example you can not output a stream of 2/3 of the runtimes´ audio signal rate or make its object box appear in pink color by default.

the only difference is that you could build an external which is different from the vanilla ones say like a router object which can be connected to other instances without patch cords and combines the functions of gate and s/r.

Roman, I might have not explained myself as clearly as I intended.
Every time you want to interface with the patcher you are required to follow certain rules, you have to create inlets and outlets, format your data in a certain way, etc... In C/C++ you get to decide how you communicate among instances of your classes, and how you format your data. So INTERNALLY you are able to engineer the architecture of your software at a much more detailed level. Maybe the keyword I was missing is INTERNALLY. Every time you communicate with the patcher, you gotta go back to following the same rules again. However coding in C/C++ makes it possible to do the heavy lifting INTERNALLY without having to deal with the idiosyncrasies of the patcher itself.
If you think about it, that summarizes the architecture of Jitter for example. In Jitter you always need to write a Max wrapper for whatever functionality the underlining Jitter object implements. Every Jitter object is patcher agnostic. The Max wrapper makes it communicate with the patcher in the way that Max requires.

roman,

i'm not sure if i get your point nor i know your experience level on procedural languages. you are talking about vanilla pd? i think it is a platform completely different from max isn't it?

we're discussing whats the advantage of writing a max external compared to max patchers? or the difference between vanilla externals compared to max externals? is vanilla compatible with max?

generally:

you need the way into "normal" procedural code because procedural problems are a pure hell solving them in a systems like max patcher. (though it's possible)

when luigi says, everything is open he means literally everything. using scripting languages or other shells often has limitations. for example there is no way direct way to call java methods from a java script. once you are at c or c++ (machine level) you can literally adapt anything that exists in the computer world in the fastest possible runtime speed. (you might even write assembler/machine code there)

that is when you need "externals" or a just a (c) api like a lot of applcations/frameworks provide (acutally max is a framework). if a component reaches a certain level of complexity you really have easier life when you go to the procedural level.

compare this patcher

with these few lines of code: they do quite the same just that the patcher is still buggy after >20 hours of work where the procedure works fine after <1h of coding. und runs many times faster ;) That is because the semantics of max patcher is just not suitable for such kind of problem.

internal IEnumerable<int[]> GetFeedbackLoops(int aColumn, int aRow)
{
var aFeedbackLoops = new List<int[]>();
foreach (var aCurrRow in Enumerable.Range(0, this.IoCount))
{
this.GetFeedbackLoops(aColumn, aRow, aCurrRow,
new List<int>(), aFeedbackLoops);
}
return aFeedbackLoops.ToArray();
}
private void GetFeedbackLoops(int aColumn,
int aRow,
int aCurrRow,
List<int> aPath,
List<int[]> aFeedbackLoops
)
{
foreach (var aCurrCol in Enumerable.Range(0, this.IoCount))
{
if (aCurrCol == 0)
{
// out[0] is main out.
// => Mapping to out[0] always possible.
}
else if ((aRow == aCurrRow && aCurrCol == aColumn)
|| this[aCurrCol, aCurrRow])
{
if (aPath.Contains(aCurrCol))
{
aFeedbackLoops.Add(aPath.ToArray());
}
else
{
aPath.Add(aCurrCol);
this.GetFeedbackLoops(aColumn,
aRow,
aCurrCol,
aPath,
aFeedbackLoops);
aPath.RemoveAt(aPath.Count - 1);
}
}
}
}

Charly, thank you for the example.
Excuse the newb question: how did you actually tell the patcher/Max this code?

Yes, thank you Charly. 100% agree. Charly's example is a great explanation in and of itself.
Max is more of an environment for object-oriented style of programming.
Patcher semantics are just not suitable for procedural programming.
Frequency analysis/resynthesis is another striking example.
Even though the Cycling74 team did a remarkable job implementing frequency domain processing in Max, it still suffers from many inefficiencies and limitations.
(i.e. try to change the FFT size dynamically...)

"or the difference between vanilla externals compared to max externals? is vanilla compatible with max?"

no, "vanilla max" as in "only with factory objects".

avoiding dependencies includes avoiding custom externals. :)

i understood luigi would suggest to write a custom external which can script-connect other externals in a max patcher instead of using [thispatcher], so i was wondering what could be done better if you do it this way.

(and it seems to make more sense to put all the functionality in one external, like you just did.)

"That is because the semantics of max patcher is just not suitable for such kind of problem"

if you are a max user you might already have that patcher - or a better version of it - in your abstractions collection. and have you checked that there is not an external by someone else already which does the same? :)

while it is clear that there are things which are easier in C++, you withheld the information about how many hours you already invested in learning C++ before you were able to save a few hours for that example. so it remains a solution for the small minority of users who already knew it before.

njaaa... i code for about 30 years now. (started with 10 or so)
max i only know for some years now though i did not do to intensively with it.
but it is not like "it works better if you can do it." it's more like a screwdriver and a hammer. you can use a screwdriver for a hammering a nail but it will never work so well and efficient. you see by just looking at the code size, that it is much more to write and so it behaves in all languages. choose the right language and you can do the same stuff with less code and/or more functionality. / better overview

@omar: just imagine these two prototypes to call the f() function from c#:

void declspec(__dllexport) f(); // c-function
[DllImport("MyDll.dll")] external void f(); // c# function
void main() { f(); } // main function in c# calling c function in dll.

there is some more stuff about unmanaged exports and member methods but thats a bit more complicated. but this is required to realize calls in both ways - from the c to c# and a call in the other direction. like ping pong game ;)

i understood luigi would suggest to write a custom external which can script-connect other externals in a max patcher instead of using [thispatcher], so i was wondering what could be done better if you do it this way.

ok... well since there seems to be no difference between a "normal" max object and a custom external - each object basically can call each other objects. even without knowing it's specific type...

so, now i forgot this one.

"you can use a screwdriver for a hammering a nail but it will never work so well and efficient."

it is clear that you will always code more effectice in C++ even if you are on the same level in both worlds.

i am just saying that you can do a lot more in max than putting objects randomly together until the screen is full. and i somehow suspected that this is what you were doing in your first approach - and then you compared the result to your professionally assembled, 30-years-experience C code saying "look, that´s easier". :D

now look how the same thing can look in max in comparison.

it is less flexible and runs slower - because it is max. and in max i would have quite some problems, if i would like to extend it from 10 to 100.

but which is better to read, and which is less code?

and btw.: this same max code will work with strings, numbers, arrays, audio signals and video.
you also dont have to remember any variables´ names, you just connect stuff to the abstraction.
and it will continue to work in max 9.5 on an ARM based apple computer.

private void UpdateMixerMatrixPatcher()
{
  var aParentPatcher = this.ParentPatcher;
  var aMixerMatrixPatcher = aParentPatcher
    .GetSubPatcher("MixerMatrixPatcher");
  var aObjPrefix = "MixerMatrixObj";
  var aGetDynObjName = new Func<string, int, string>
    (delegate (string aPrefix, int aNamedObjIdx)
  {
    return aPrefix + "[" + aNamedObjIdx + "]";
  });
  var aGetStaticObjName = new Func<string, int, string>
    (delegate (string aPrefix, int aNamedObjIdx)
  {
    return aGetDynObjName(aPrefix, aNamedObjIdx);
  });
  { // DeleteOldObjects
    var aDone = false;
    for (var aObjIdx = 0; !aDone;++aObjIdx)
    {
        var aName = aGetDynObjName(aObjPrefix, aObjIdx);
        if (aMixerMatrixPatcher.GetContainsObject(aName))
        {
          var aObj = aMixerMatrixPatcher.GetBox(aName);
          aObj.Delete();
        }
        else
        {
          aDone = true;
        }
    }
  }

  { // AddNewObjects
    var aObjIdx = 0;
    var aGenObjectName = new Func<string>(() =>
    {
        var aName = aGetDynObjName(aObjPrefix, aObjIdx);
        ++aObjIdx;
        return aName;
    });
    var aCsState = this.CsState;
    var aFlowMatrix = aCsState.FlowMatrix;
    var aChannels = aFlowMatrix.Channels;
    var aIoCount = this.IoCount;
    var aMainIn = aMixerMatrixPatcher.GetBox("MainIn");
    var aMainOut = aMixerMatrixPatcher.GetBox("MainOut");
    var aOutputs = new CPatBox[aIoCount];
    for(var aOuputIdx = 0; aOuputIdx < aIoCount; ++aOuputIdx)
    {
        var aVstOutName = aGetStaticObjName("VstOut", aOuputIdx);
        var aVstOutObj = aMixerMatrixPatcher.GetBox(aVstOutName);
        aOutputs[aOuputIdx] = aVstOutObj;
    }
    var aInputs = new CPatBox[aIoCount];
    for (var aInputIdx = 0; aInputIdx < aIoCount; ++aInputIdx)
    {
        var aVstInName = aGetStaticObjName("VstIn", aInputIdx);
        var aVstInObj = aMixerMatrixPatcher.GetBox(aVstInName);
        aInputs[aInputIdx] = aVstInObj;
    }
    var aAddDelay = new Func<int, int, CPatBox>(delegate
      (int aDelayChannelIdx, int aDelayTime)
    {
        var aInput = aInputs[aDelayChannelIdx]; 
        var aSkipDelayIsAllowed = false; // can not delete cable 0->0 atm...
        if (aDelayTime == 0
        && aSkipDelayIsAllowed)
        {                  
          return aInput;
        }
        else
        {
          var aArgs = "" + aDelayTime + " " + aDelayTime;
          var aObjectName = aGenObjectName();
          var aBoxText = "mc.delay~ " + aDelayTime + " " + aDelayTime;
          var aDelay = aMixerMatrixPatcher.Add(aBoxText, aObjectName);
          aDelay.Outlets[0].ConnectTo(aInput.Inlets[0]);
          return aDelay;
        }
    });

    for(var aChannelIdx = 0; aChannelIdx < aIoCount; ++aChannelIdx)
    {
        var aChannel = aChannels.Channels[aChannelIdx];
        var aInputObj = aChannelIdx == 0
                      ? aMainIn
                      : aOutputs[aChannelIdx];
        foreach (var aOutputChannel in aChannel.OutputsWithoutMainOut)
        {
          var aInputChannelIdx = aOutputChannel.Inputs.IndexOf(aChannel);
          var aLatencyCompensation = aOutputChannel
            .LatencyCompensations[aInputChannelIdx];
          var aTargetInput = aAddDelay
            (aOutputChannel.IoIdx, aLatencyCompensation);
          aInputObj.Outlets[0].ConnectTo(aTargetInput.Inlets[0]);
        }
    }
  }
} [/code]