I've got a toy QML app (Qt 5.7) that consists of the following QML page plus some C++ code that allows the QML to subscribe to some state on an audio device and reflect that state in the QML GUI. The toy QML looks like this:

```
import QtQuick 2.6
import QtQuick.Controls 1.5
import QtQuick.Window 2.2

Item {
   id: deviceState

   property bool mute1: false
   property bool mute2: false
   property bool mute3: false
   property bool mute4: false

   Component.onCompleted: {
      // Call out to C++ land, to tell the server what 
      // control points we are interested in tracking the state of
      topLevelWindow.subscribeToControlPoints("Input 1-4 Mute", deviceState);
   }

   // Called by C++ land to tell us the current state of
   // a control point we previously subscribed to.
   function onControlPointValueUpdated(address, value) {
      if (address == "Input 1 Mute") {
         mute1 = value
      }
      else if (address == "Input 2 Mute") {
         mute2 = value
      }
      else if (address == "Input 3 Mute") {
         mute3 = value
      }
      else if (address == "Input 4 Mute") {
         mute4 = value
      }
   }

   // Absurdly minimalist example GUI
   Text {
      text: parent.mute4 ? "MUTED" : "unmuted"
   }
}

```

When I run this, my C++ code calls onControlPointValueUpdated() whenever one of the four mute-states on my audio device changes, and based on the 'address' argument in the call, one of the four muteN QML properties is changed. And, whenever the mute4 property is changed, the text in the Text area is updated to reflect that.

This all works fine, as far as it goes, but at some point I'm going to need to scale it up; in particular I will need to track hundreds or thousands of values rather than just four, and having to manually declare an individual, hand-named QML property for each value would quickly become arduous and difficult to maintain; and the implementation of onControlPointValueUpdated() would become very inefficient if it has to manually if/elseif its way through every property.

So my question is, is there some way in QML for me to declare an array (or better yet, a dictionary/map) of properties, so that I can declare a large number of QML properties at once? i.e. something like this:

```
property bool mutes[256]: {false}   // would declare mutes[0] through mutes[255], all default to false

```

... or if not, is there some other recommended approach to holding large amounts of observable state within a QML document? I like the ability to have my GUI widgets bind to a QML property to get automatically updated as necessary, but it seems like perhaps QML properties weren't intended to be used *en masse*?