FR: Extending dsp::ProcessSpec to pass custom specs to custom processors in a ProcessorChain

Feature Requests
1

While for a lot of processors, sample rate, max block size and number of channels is enough information to prepare them, some more complex custom processors need more specs to be prepared correctly. In this cases I find myself writing something like

chain.get<processorA>().prepare (spec);
chain.get<processorB>().prepare (spec, additionalSpecForB);
chain.get<processorC>().prepare (spec, additionalSpecForC);
chain.get<processorD>().prepare (spec);

Wouldn’t it be nice to be able to pass those additional spec through the ProcessorChain’s prepare call? I think of some extension like this:

class ProcessSpec
{
public:
    /** Constructor to be compatible to existing code initializing the object */
    ProcessSpec (double initialSampleRate, uint32 initialMaxBlockSize, uint32 initialNumChannels)
            : sampleRate (initialSampleRate),
              maximumBlockSize (initialMaxBlockSize),
              numChannels (initialNumChannels)
    {}
    
    ProcessSpec() {}

    /** The sample rate that will be used for the data that is sent to the processor. */
    double sampleRate;

    /** The maximum number of samples that will be in the blocks sent to process() method. */
    uint32 maximumBlockSize;

    /** The number of channels that the process() method will be expected to handle. */
    uint32 numChannels;

    bool hasAdditionalSpec() { return ! additionalSpec.isEmpty(); }
    
    /** Set some additional processor specific spec. The type has to be convertible to a var. Make sure that a unique
        identifier is chosen 
     */
    template <typename Type>
    void setAdditionalSpec (const Identifier& uniqueID, Type&& value) 
    { 
        additionalSpec.set (uniqueID, std::forward<Type> (value));
    }
    
    /** Returns some additional processor specific spec previously set with setAdditionalSpec */
    const var& getAdditionalSpec (const Identifier& uniqueID) const
    { 
        auto& value = additionalSpec[uniqueID];
        
        jassert (!value.isVoid()); // There is no value for the id passed in
        return value;
    }

private:
    NamedValueSet additionalSpec;
};

This should not break existing code but make the whole ProcessSpec thing much more powerful. What do you think?