@qooxdoo/framework 7.9.2 → 8.0.0-beta.2

package/source/class/qx/data/SingleValueBinding.js

@@ -5,1547 +5,637 @@
    http://qooxdoo.org
 
    Copyright:
-     2004-2008 1&1 Internet AG, Germany, http://www.1und1.de
+     2022-2023 Zenesis Limited, https://www.zenesis.com
 
    License:
      MIT: https://opensource.org/licenses/MIT
      See the LICENSE file in the project's top-level directory for details.
 
    Authors:
-     * Martin Wittemann (martinwittemann)
+     * John Spackman (https://github.com/johnspackman, john.spackman@zenesis.com)
+     * Patryk Malinowski (https://github.com/patryk-m-malinowski, pmalinowski116@gmail.com)
 
 ************************************************************************ */
 
 /**
- * Single-value binding is a core component of the data binding package.
+ * This class implements bindings as a first class object.
+ *
+ * The Binding has a source, a value, and optional target; the source (and
+ * sourcePath) is read and copied into value; the value is copied into the target
+ * if there is one.
+ *
+ * If the sourcePath is null, then the value will be the source object; if the
+ * target or the targetPath is null, then the `value` will still update but will
+ * not be copied anywhere
+ *
+ * Arrays are supported by including `[]` in paths, eg `children[2]`, although this
+ * only works with `sourcePath` and not in `targetPath`.  Arrays can be native or
+ * `qx.data.Array`, but changes to native arrays will not be detected because they
+ * dont fire events
+ *
+ * @typedef {[qx.data.SingleValueBinding, qx.core.Object, string, qx.core.Object, string]} BindingRecord Array representation of the binding,
+ * containing the binding, source object, source path, target object and target path respectively.
  */
 qx.Class.define("qx.data.SingleValueBinding", {
-  statics: {
-    /** internal reference for all bindings indexed by source object */
-    __bindings: {},
+  extend: qx.core.Object,
+  implement: [qx.data.binding.IInputReceiver],
+
+  /**
+   * The class is responsible for binding a source objects property to
+   * a target objects property. Both properties have to have the usual qooxdoo
+   * getter and setter. The source property also needs to fire change-events
+   * on every change of its value.
+   * Please keep in mind, that this binding is unidirectional. If you need
+   * a binding in both directions, you have to use two of this bindings.
+   *
+   * It's also possible to bind some kind of a hierarchy as a source. This
+   * means that you can separate the source properties with a dot and bind
+   * by that the object referenced to this property chain.
+   * Example with an object 'a' which has object 'b' stored in its 'child'
+   * property. Object b has a string property named abc:
+   * <pre><code>
+   * qx.data.SingleValueBinding.bind(a, "child.abc", textfield, "value");
+   * </code></pre>
+   * In that case, if the property abc of b changes, the textfield will
+   * automatically contain the new value. Also if the child of a changes, the
+   * new value (abc of the new child) will be in the textfield.
+   *
+   * There is also a possibility of binding an array. Therefore the array
+   * {@link qx.data.IListData} is needed because this array has change events
+   * which the native does not. Imagine a qooxdoo object a which has a
+   * children property containing an array holding more of its own kind.
+   * Every object has a name property as a string.
+   * <pre>
+   * var svb = qx.data.SingleValueBinding;
+   * // bind the first child's name of 'a' to a textfield
+   * svb.bind(a, "children[0].name", textfield, "value");
+   * // bind the last child's name of 'a' to a textfield
+   * svb.bind(a, "children[last].name", textfield2, "value");
+   * // also deeper bindings are possible
+   * svb.bind(a, "children[0].children[0].name", textfield3, "value");
+   * </pre>
+   *
+   * As you can see in this example, the abc property of a's b will be bound
+   * to the textfield. If now the value of b changed or even the a will get a
+   * new b, the binding still shows the right value.
+   *
+   * @param {qx.core.Object?} sourceObject The source of the binding.
+   * @param {String} sourcePropertyChain The property chain which represents
+   *   the source property.
+   * @param {qx.core.Object?} targetObject The object which the source should
+   *   be bound to.
+   * @param {String} targetPropertyChain The property chain to the target
+   *   object.
+   * @param {BindingOptions} options A map containing the options.
+   *
+   * @typedef BindingOptions
+   * @property {converter} converter Data converter function. If no conversion has been done, the given value should be returned.
+   * e.g. a number to boolean converter
+   * <code>function(data, model, source, target) {return data > 100;}</code>
+   * @property {onUpdate} onUpdate This callback will be called if the binding was updated successfully.
+   * @property {() => void} onSetFail A callback function can be given here. This function will
+   *       be called if the set of the value fails.
+   * @property {string} ignoreConverter A string which will be matched using the current
+   *       property chain. If it matches, the converter will not be called.
+   * 
+   *
+   * @callback converter
+   * @param {*} data The data to convert
+   * @param {*} model The corresponding model object, which is only set in case of the use of an controller.
+   * @param {qx.core.Object} source The source object for the binding
+   * @param {qx.core.Object} target The target object
+   * @returns {*} The converted data
+   * 
+   * @callback onUpdate
+   * @param {qx.core.Object} source The source object for the binding
+   * @param {qx.core.Object} target The target object
+   * @param {*} data The data
+       
+  *
+  * @returns {qx.data.SingleValueBinding} Returns the internal id for that binding. This can be used
+  *   for referencing the binding or e.g. for removing. This is not an atomic
+  *   id so you can't you use it as a hash-map index.
+  *
+  * @throws {qx.core.AssertionError} If the event is no data event or
+  *   there is no property definition for object and property (source and
+  *   target).
+  */
+  construct(sourcePath, targetPath, source, target, options) {
+    super();
+    if (!(sourcePath || targetPath)) {
+      throw new Error("SourcePath and targetPath must be specified");
+    }
+    this.__options = options ?? {};
+    let tracker = {};
+
+    const Utils = qx.event.Utils;
+    this.setSourcePath(sourcePath);
+    this.setTargetPath(targetPath);
+    Utils.then(tracker, () => source && this.setSource(source));
+    Utils.then(tracker, () => target && this.setTarget(target));
+  },
+
+  destruct() {
+    if (this.__sourceSegments) {
+      this.__sourceSegments.forEach(segment => segment.dispose());
+      this.__sourceSegments = null;
+    }
+    if (this.__targetSegments) {
+      this.__targetSegments.forEach(segment => segment.dispose());
+      this.__targetSegments = null;
+    }
+    this.setSource(null);
+    this.setTarget(null);
+  },
+
+  properties: {
+    /** The path into the `source` object */
+    sourcePath: {
+      init: null,
+      nullable: true,
+      check: "String",
+      event: "changeSourcePath",
+      apply: "_applySourcePath"
+    },
 
-    /** internal reference for all bindings indexed by target object */
-    __bindingsByTarget: {},
+    /** The path into the `target` object */
+    targetPath: {
+      init: null,
+      nullable: true,
+      check: "String",
+      event: "changeTargetPath",
+      apply: "_applyTargetPath"
+    }
+  },
 
+  members: {
     /**
-     * The function is responsible for binding a source objects property to
-     * a target objects property. Both properties have to have the usual qooxdoo
-     * getter and setter. The source property also needs to fire change-events
-     * on every change of its value.
-     * Please keep in mind, that this binding is unidirectional. If you need
-     * a binding in both directions, you have to use two of this bindings.
-     *
-     * It's also possible to bind some kind of a hierarchy as a source. This
-     * means that you can separate the source properties with a dot and bind
-     * by that the object referenced to this property chain.
-     * Example with an object 'a' which has object 'b' stored in its 'child'
-     * property. Object b has a string property named abc:
-     * <pre><code>
-     * qx.data.SingleValueBinding.bind(a, "child.abc", textfield, "value");
-     * </code></pre>
-     * In that case, if the property abc of b changes, the textfield will
-     * automatically contain the new value. Also if the child of a changes, the
-     * new value (abc of the new child) will be in the textfield.
-     *
-     * There is also a possibility of binding an array. Therefore the array
-     * {@link qx.data.IListData} is needed because this array has change events
-     * which the native does not. Imagine a qooxdoo object a which has a
-     * children property containing an array holding more of its own kind.
-     * Every object has a name property as a string.
-     * <pre>
-     * var svb = qx.data.SingleValueBinding;
-     * // bind the first child's name of 'a' to a textfield
-     * svb.bind(a, "children[0].name", textfield, "value");
-     * // bind the last child's name of 'a' to a textfield
-     * svb.bind(a, "children[last].name", textfield2, "value");
-     * // also deeper bindings are possible
-     * svb.bind(a, "children[0].children[0].name", textfield3, "value");
-     * </pre>
-     *
-     * As you can see in this example, the abc property of a's b will be bound
-     * to the textfield. If now the value of b changed or even the a will get a
-     * new b, the binding still shows the right value.
-     *
-     * @param sourceObject {qx.core.Object} The source of the binding.
-     * @param sourcePropertyChain {String} The property chain which represents
-     *   the source property.
-     * @param targetObject {qx.core.Object} The object which the source should
-     *   be bind to.
-     * @param targetPropertyChain {String} The property chain to the target
-     *   object.
-     * @param options {Map?null} A map containing the options.
-     *   <li>converter: A converter function which takes four parameters
-     *       and should return the converted value.
-     *       <ol>
-     *         <li>The data to convert</li>
-     *         <li>The corresponding model object, which is only set in case of the use of an controller.</li>
-     *         <li>The source object for the binding</li>
-     *         <li>The target object.</li>
-     *       </ol>
-     *       If no conversion has been done, the given value should be returned.
-     *       e.g. a number to boolean converter
-     *       <code>function(data, model, source, target) {return data > 100;}</code>
-     *   </li>
-     *   <li>onUpdate: A callback function can be given here. This method will be
-     *       called if the binding was updated successful. There will be
-     *       three parameter you do get in that method call.
-     *       <ol>
-     *         <li>The source object</li>
-     *         <li>The target object</li>
-     *         <li>The data</li>
-     *       </ol>
-     *       Here is a sample: <code>onUpdate : function(source, target, data) {...}</code>
-     *   </li>
-     *   <li>onSetFail: A callback function can be given here. This method will
-     *       be called if the set of the value fails.
-     *   </li>
-     *   <li>ignoreConverter: A string which will be matched using the current
-     *       property chain. If it matches, the converter will not be called.
-     *   </li>
-     *
-     * @return {var} Returns the internal id for that binding. This can be used
-     *   for referencing the binding or e.g. for removing. This is not an atomic
-     *   id so you can't you use it as a hash-map index.
-     *
-     * @throws {qx.core.AssertionError} If the event is no data event or
-     *   there is no property definition for object and property (source and
-     *   target).
+     * @type {*}
      */
-    bind(
-      sourceObject,
-      sourcePropertyChain,
-      targetObject,
-      targetPropertyChain,
-      options
-    ) {
-      // check for the arguments
-      if (qx.core.Environment.get("qx.debug")) {
-        qx.core.Assert.assertObject(sourceObject, "sourceObject");
-        qx.core.Assert.assertString(sourcePropertyChain, "sourcePropertyChain");
-        qx.core.Assert.assertObject(targetObject, "targetObject");
-        qx.core.Assert.assertString(targetPropertyChain, "targetPropertyChain");
-      }
-
-      // set up the target binding
-      var targetListenerMap = this.__setUpTargetBinding(
-        sourceObject,
-        sourcePropertyChain,
-        targetObject,
-        targetPropertyChain,
-        options
-      );
-
-      // get the property names
-      var propertyNames = sourcePropertyChain.split(".");
-
-      // stuff that's needed to store for the listener function
-      var arrayIndexValues = this.__checkForArrayInPropertyChain(propertyNames);
-      var sources = [];
-      var listeners = [];
-      var listenerIds = [];
-      var eventNames = [];
-      var source = sourceObject;
-      var initialPromise = null;
-
-      // add a try catch to make it possible to remove the listeners of the
-      // chain in case the loop breaks after some listeners already added.
-      try {
-        // go through all property names
-        for (var i = 0; i < propertyNames.length; i++) {
-          var propertyName = propertyNames[i];
-
-          // check for the array
-          if (arrayIndexValues[i] !== "") {
-            // push the array change event
-            eventNames.push("change");
-          } else {
-            var eventName = this.__getEventNameForProperty(
-              source,
-              propertyName
-            );
-
-            if (!eventName) {
-              if (i == 0) {
-                // the root property can not change --> error
-                throw new qx.core.AssertionError(
-                  "Binding property " +
-                    propertyName +
-                    " of object " +
-                    source +
-                    " not possible: No event available. Full property chain: " +
-                    sourcePropertyChain
-                );
-              }
-
-              if (
-                source instanceof qx.core.Object &&
-                qx.Class.hasProperty(source.constructor, propertyName)
-              ) {
-                qx.log.Logger.warn(
-                  "Binding property " +
-                    propertyName +
-                    " of object " +
-                    source +
-                    " not possible: No event available. Full property chain: " +
-                    sourcePropertyChain
-                );
-              }
-
-              // call the converter if no event could be found on binding creation
-              initialPromise = this.__setInitialValue(
-                undefined,
-                targetObject,
-                targetPropertyChain,
-                options,
-                sourceObject
-              );
-
-              break;
-            }
-            eventNames.push(eventName);
-          }
+    __value: undefined,
+    /**
+     * @type {qx.core.Object}
+     */
+    __source: null,
 
-          // save the current source
-          sources[i] = source;
-
-          // check for the last property
-          if (i == propertyNames.length - 1) {
-            // if it is an array, set the initial value and bind the event
-            if (arrayIndexValues[i] !== "") {
-              // get the current value
-              var itemIndex =
-                arrayIndexValues[i] === "last"
-                  ? source.length - 1
-                  : arrayIndexValues[i];
-              var currentValue = source.getItem(itemIndex);
-
-              // set the initial value
-              initialPromise = this.__setInitialValue(
-                currentValue,
-                targetObject,
-                targetPropertyChain,
-                options,
-                sourceObject
-              );
-
-              // bind the event
-              listenerIds[i] = this.__bindEventToProperty(
-                source,
-                eventNames[i],
-                targetObject,
-                targetPropertyChain,
-                options,
-                arrayIndexValues[i]
-              );
-            } else {
-              // try to set the initial value
-              if (
-                propertyNames[i] != null &&
-                source["get" + qx.lang.String.firstUp(propertyNames[i])] != null
-              ) {
-                var currentValue =
-                  source["get" + qx.lang.String.firstUp(propertyNames[i])]();
-                initialPromise = this.__setInitialValue(
-                  currentValue,
-                  targetObject,
-                  targetPropertyChain,
-                  options,
-                  sourceObject
-                );
-              }
-              // bind the property
-              listenerIds[i] = this.__bindEventToProperty(
-                source,
-                eventNames[i],
-                targetObject,
-                targetPropertyChain,
-                options
-              );
-            }
-
-            // if its not the last property
-          } else {
-            // create the context for the listener
-            var context = {
-              index: i,
-              propertyNames: propertyNames,
-              sources: sources,
-              listenerIds: listenerIds,
-              arrayIndexValues: arrayIndexValues,
-              targetObject: targetObject,
-              targetPropertyChain: targetPropertyChain,
-              options: options,
-              listeners: listeners
-            };
-
-            // create a listener
-            var listener = qx.lang.Function.bind(
-              this.__chainListener,
-              this,
-              context
-            );
+    /**
+     * @type {BindingRecord?}
+     */
+    __record: null,
 
-            // store the listener for further processing
-            listeners.push(listener);
+    /**
+     * @type {qx.core.Object}
+     */
+    __target: null,
 
-            // add the chaining listener
-            listenerIds[i] = source.addListener(eventNames[i], listener);
-          }
+    /** @type {Promise} initialisation promise */
+    __initPromise: null,
 
-          // get and store the next source
-          if (
-            source["get" + qx.lang.String.firstUp(propertyNames[i])] == null
-          ) {
-            source = undefined;
-          } else if (arrayIndexValues[i] !== "") {
-            var itemIndex =
-              arrayIndexValues[i] === "last"
-                ? source.length - 1
-                : arrayIndexValues[i];
-            source =
-              source["get" + qx.lang.String.firstUp(propertyNames[i])](
-                itemIndex
-              );
-          } else {
-            source = source["get" + qx.lang.String.firstUp(propertyNames[i])]();
-            // the value should be undefined if we can not find the last part of the property chain
-            if (source === null && propertyNames.length - 1 != i) {
-              source = undefined;
-            }
-          }
-          if (!source) {
-            // call the converter if no source could be found on binding creation
-            this.__setInitialValue(
-              source,
-              targetObject,
-              targetPropertyChain,
-              options,
-              sourceObject
-            );
+    /** @type {qx.data.binding.AbstractSegment[]?} list of segments of the source path */
+    __sourceSegments: null,
 
-            break;
-          }
-        }
-      } catch (ex) {
-        // remove the already added listener
-        // go through all added listeners (source)
-
-        for (var i = 0; i < sources.length; i++) {
-          // check if a source is available
-          if (sources[i] && listenerIds[i]) {
-            sources[i].removeListenerById(listenerIds[i]);
-          }
-        }
-        var targets = targetListenerMap.targets;
-        var targetIds = targetListenerMap.listenerIds;
-        // go through all added listeners (target)
-        for (var i = 0; i < targets.length; i++) {
-          // check if a target is available
-          if (targets[i] && targetIds[i]) {
-            targets[i].removeListenerById(targetIds[i]);
-          }
-        }
+    /** @type {qx.data.binding.AbstractSegment[]?} list of segments of the target path */
+    __targetSegments: null,
 
-        throw ex;
-      }
-
-      // create the id map
-      var id = {
-        type: "deepBinding",
-        listenerIds: listenerIds,
-        sources: sources,
-        targetListenerIds: targetListenerMap.listenerIds,
-        targets: targetListenerMap.targets,
-        initialPromise: initialPromise
-      };
-
-      // store the bindings
-      this.__storeBinding(
-        id,
-        sourceObject,
-        sourcePropertyChain,
-        targetObject,
-        targetPropertyChain
-      );
+    /**
+     * @type {BindingOptions}
+     */
+    __options: null,
 
-      return id;
+    /**
+     * Promises/A+ thenable compliance, this means that you can await the binding for initialisation
+     * https://promisesaplus.com/
+     * @returns {Promise} the promise
+     */
+    then(onFulfilled, onRejected) {
+      return Promise.resolve(this.__initPromise).then(onFulfilled, onRejected);
     },
 
     /**
-     * Event listener for the chaining of the properties.
      *
-     * @param context {Map} The current context for the listener.
+     * @returns {BindingRecord} The representation of this binding as record.
      */
-    __chainListener(context) {
-      // invoke the onUpdate method
-      if (context.options && context.options.onUpdate) {
-        context.options.onUpdate(
-          context.sources[context.index],
-          context.targetObject
-        );
-      }
-
-      // delete all listener after the current one
-      for (var j = context.index + 1; j < context.propertyNames.length; j++) {
-        // remove the old sources
-        var source = context.sources[j];
-        context.sources[j] = null;
-        if (!source) {
-          continue;
-        }
-
-        // remove the listeners
-        source.removeListenerById(context.listenerIds[j]);
+    asRecord() {
+      if (!this.__record) {
+        this.__record = [this, this.getSource(), this.getSourcePath(), this.getTarget(), this.getTargetPath()];
       }
+      return this.__record;
+    },
 
-      // get the current source
-      var source = context.sources[context.index];
-      // add new once after the current one
-      for (var j = context.index + 1; j < context.propertyNames.length; j++) {
-        // get and store the new source
-        if (context.arrayIndexValues[j - 1] !== "") {
-          source = source[
-            "get" + qx.lang.String.firstUp(context.propertyNames[j - 1])
-          ](context.arrayIndexValues[j - 1]);
-        } else {
-          source =
-            source[
-              "get" + qx.lang.String.firstUp(context.propertyNames[j - 1])
-            ]();
-        }
-        context.sources[j] = source;
-        // reset the target object if no new source could be found
-        if (!source) {
-          // use the converter if the property chain breaks [BUG# 6880]
-          if (context.options && context.options.converter) {
-            var ignoreConverter = false;
-            // take care of the ignore pattern used for the controller
-            if (context.options.ignoreConverter) {
-              // the current property chain as string
-              var currentSourceChain = context.propertyNames
-                .slice(0, j)
-                .join(".");
-              // match for the current pattern given in the options
-              var match = currentSourceChain.match(
-                new RegExp("^" + context.options.ignoreConverter)
-              );
-
-              ignoreConverter = match ? match.length > 0 : false;
-            }
-
-            if (!ignoreConverter) {
-              this.__setTargetValue(
-                context.targetObject,
-                context.targetPropertyChain,
-                context.options.converter()
-              );
-            } else {
-              this.__resetTargetValue(
-                context.targetObject,
-                context.targetPropertyChain
-              );
-            }
-          } else {
-            this.__resetTargetValue(
-              context.targetObject,
-              context.targetPropertyChain
-            );
-          }
-
-          break;
-        }
-
-        // if its the last property
-        if (j == context.propertyNames.length - 1) {
-          // if its an array
-          if (
-            qx.Class.implementsInterface(source, qx.data.IListData) &&
-            context.arrayIndexValues[j] !== ""
-          ) {
-            // set the initial value
-            var itemIndex =
-              context.arrayIndexValues[j] === "last"
-                ? source.length - 1
-                : context.arrayIndexValues[j];
-            var currentValue = source.getItem(itemIndex);
-            this.__setInitialValue(
-              currentValue,
-              context.targetObject,
-              context.targetPropertyChain,
-              context.options,
-              context.sources[context.index]
-            );
-
-            // bind the item event to the new target
-            context.listenerIds[j] = this.__bindEventToProperty(
-              source,
-              "change",
-              context.targetObject,
-              context.targetPropertyChain,
-              context.options,
-              context.arrayIndexValues[j]
-            );
-          } else {
-            if (
-              context.propertyNames[j] != null &&
-              source[
-                "get" + qx.lang.String.firstUp(context.propertyNames[j])
-              ] != null
-            ) {
-              var currentValue =
-                source[
-                  "get" + qx.lang.String.firstUp(context.propertyNames[j])
-                ]();
-
-              this.__setInitialValue(
-                currentValue,
-                context.targetObject,
-                context.targetPropertyChain,
-                context.options,
-                context.sources[context.index]
-              );
-            }
-            var eventName = this.__getEventNameForProperty(
-              source,
-              context.propertyNames[j]
-            );
-
-            if (!eventName) {
-              context.sources[j] = null;
-              this.__resetTargetValue(
-                context.targetObject,
-                context.targetPropertyChain
-              );
-
-              return;
-            }
-            // bind the last property to the new target
-            context.listenerIds[j] = this.__bindEventToProperty(
-              source,
-              eventName,
-              context.targetObject,
-              context.targetPropertyChain,
-              context.options
-            );
-          }
-        } else {
-          // check if a listener already created
-          if (context.listeners[j] == null) {
-            var listener = qx.lang.Function.bind(
-              this.__chainListener,
-              this,
-              context
-            );
-
-            // store the listener for further processing
-            context.listeners.push(listener);
-          }
-          // add a new listener
-          if (qx.Class.implementsInterface(source, qx.data.IListData)) {
-            var eventName = "change";
-          } else {
-            var eventName = this.__getEventNameForProperty(
-              source,
-              context.propertyNames[j]
-            );
-          }
+    /**
+     * @override
+     */
+    toString() {
+      return `${super.toString()}: ${this.getSource()}.${this.getSourcePath()} -> ${this.getTarget()}.${this.getTargetPath()}`;
+    },
 
-          if (!eventName) {
-            context.sources[j] = null;
-            this.__resetTargetValue(
-              context.targetObject,
-              context.targetPropertyChain
-            );
+    /**
+     *
+     * @returns {Promise} A promise which resolves when the initial value has been copied over from source to target
+     */
+    getInitPromise() {
+      return this.__initPromise;
+    },
 
-            return;
-          }
-          context.listenerIds[j] = source.addListener(
-            eventName,
-            context.listeners[j]
-          );
-        }
-      }
+    /**
+     * Apply for `sourcePath`
+     */
+    _applySourcePath(value, oldValue) {
+      if (oldValue) {
+        throw new Error("Cannot change sourcePath after binding has been created");
+      }
+      this.__record = null; // invalidate record representation cache
+      this.__sourceSegments = qx.data.SingleValueBinding.__parseSegments(this, value);
+      let lastSegment = this.__sourceSegments.at(-1);
+      lastSegment.setOutputReceiver(this);
     },
 
     /**
-     * Internal helper for setting up the listening to the changes on the
-     * target side of the binding. Only works if the target property is a
-     * property chain
+     * Sets the source object of this binding.
+     * If a target is set, the target will be updated with source's value.
      *
-     * @param sourceObject {qx.core.Object} The source of the binding.
-     * @param sourcePropertyChain {String} The property chain which represents
-     *   the source property.
-     * @param targetObject {qx.core.Object} The object which the source should
-     *   be bind to.
-     * @param targetPropertyChain {String} The property name of the target
-     *   object.
-     * @param options {Map} The options map perhaps containing the user defined
-     *   converter.
-     * @return {var} A map containing the listener ids and the targets.
+     * @param {qx.core.Object?} value The source object to get the `value` by looking up `sourcePath`
+     * @returns {Promise?} A promise if any stage of the process was asynchronous, i.e. we had to get a property asynchronously along the source/target path,
+     * or setting the target was asynchronous.
+     * If everything was synchronous, then this will return null.
      */
-    __setUpTargetBinding(
-      sourceObject,
-      sourcePropertyChain,
-      targetObject,
-      targetPropertyChain,
-      options
-    ) {
-      // get the property names
-      var propertyNames = targetPropertyChain.split(".");
-
-      var arrayIndexValues = this.__checkForArrayInPropertyChain(propertyNames);
-      var targets = [];
-      var listeners = [];
-      var listenerIds = [];
-      var eventNames = [];
-      var target = targetObject;
-
-      // go through all property names
-      for (var i = 0; i < propertyNames.length - 1; i++) {
-        // check for the array
-        if (arrayIndexValues[i] !== "") {
-          // push the array change event
-          eventNames.push("change");
-        } else {
-          var eventName = this.__getEventNameForProperty(
-            target,
-            propertyNames[i]
-          );
-
-          if (!eventName) {
-            // if the event names could not be terminated,
-            // just ignore the target chain listening
-            break;
-          }
-          eventNames.push(eventName);
+    setSource(value) {
+      const SingleValueBinding = qx.data.SingleValueBinding;
+      if (this.__source === value) {
+        return;
+      }
+
+      this.__record = null; // invalidate record representation cache
+      let oldValue = this.__source;
+      this.__source = value;
+      this.__initPromise = null; // reset the init promise, as the source has changed
+
+      if (oldValue) {
+        //Delete old source's bindings if there was one
+        delete SingleValueBinding.__bindingsBySource[oldValue.toHashCode()][this.toHashCode()];
+        if (qx.lang.Object.isEmpty(SingleValueBinding.__bindingsBySource[oldValue.toHashCode()])) {
+          delete SingleValueBinding.__bindingsBySource[oldValue.toHashCode()];
         }
+      }
 
-        // save the current source
-        targets[i] = target;
-
-        // create a listener
-        var listener = function () {
-          // delete all listener after the current one
-          for (var j = i + 1; j < propertyNames.length - 1; j++) {
-            // remove the old sources
-            var target = targets[j];
-            targets[j] = null;
-            if (!target) {
-              continue;
-            }
-
-            // remove the listeners
-            target.removeListenerById(listenerIds[j]);
-          }
+      if (value) {
+        //Store the binding
+        SingleValueBinding.__bindingsBySource[value.toHashCode()] ??= {};
+        SingleValueBinding.__bindingsBySource[value.toHashCode()][this.toHashCode()] = this;
 
-          // get the current target
-          var target = targets[i];
-          // add new once after the current one
-          for (var j = i + 1; j < propertyNames.length - 1; j++) {
-            var firstUpPropName = qx.lang.String.firstUp(propertyNames[j - 1]);
-            // get and store the new target
-            if (arrayIndexValues[j - 1] !== "") {
-              var currentIndex =
-                arrayIndexValues[j - 1] === "last"
-                  ? target.getLength() - 1
-                  : arrayIndexValues[j - 1];
-              target = target["get" + firstUpPropName](currentIndex);
-            } else {
-              target = target["get" + firstUpPropName]();
-            }
-            targets[j] = target;
-            if (!target) {
-              break;
-            }
-
-            // check if a listener already created
-            if (listeners[j] == null) {
-              // store the listener for further processing
-              listeners.push(listener);
-            }
-
-            // add a new listener
-            if (qx.Class.implementsInterface(target, qx.data.IListData)) {
-              var eventName = "change";
-            } else {
-              var eventName =
-                qx.data.SingleValueBinding.__getEventNameForProperty(
-                  target,
-                  propertyNames[j]
-                );
-
-              if (!eventName) {
-                // if the event name could not be terminated,
-                // ignore the rest
-                break;
-              }
-            }
-
-            listenerIds[j] = target.addListener(eventName, listeners[j]);
+        //Set the input on the first segment of the source path
+        let out = this.__sourceSegments[0].setInput(value);
+        const cb = () => {
+          if (qx.core.Environment.get("qx.debug")) {
+            this.assertNotNull(
+              this.__sourceSegments[0].getEventName(),
+              `Binding property ${this.__sourceSegments[0].toString()} of object ${value.classname} not possible. No event available.`
+            );
           }
-
-          qx.data.SingleValueBinding.updateTarget(
-            sourceObject,
-            sourcePropertyChain,
-            targetObject,
-            targetPropertyChain,
-            options
-          );
         };
 
-        // store the listener for further processing
-        listeners.push(listener);
-
-        // add the chaining listener
-        listenerIds[i] = target.addListener(eventNames[i], listener);
-
-        var firstUpPropName = qx.lang.String.firstUp(propertyNames[i]);
-        // get and store the next target
-        if (target["get" + firstUpPropName] == null) {
-          target = null;
-        } else if (arrayIndexValues[i] !== "") {
-          target = target["get" + firstUpPropName](arrayIndexValues[i]);
+        if (qx.Promise.isPromise(out)) {
+          out = out.then(cb);
         } else {
-          target = target["get" + firstUpPropName]();
-        }
-        if (!target) {
-          break;
+          out = cb();
         }
+        this.__initPromise = Promise.resolve(out);
+        return out;
       }
-
-      return { listenerIds: listenerIds, targets: targets };
     },
 
     /**
-     * Helper for updating the target. Gets the current set data from the source
-     * and set that on the target.
-     *
-     * @param sourceObject {qx.core.Object} The source of the binding.
-     * @param sourcePropertyChain {String} The property chain which represents
-     *   the source property.
-     * @param targetObject {qx.core.Object} The object which the source should
-     *   be bind to.
-     * @param targetPropertyChain {String} The property name of the target
-     *   object.
-     * @param options {Map} The options map perhaps containing the user defined
-     *   converter.
-     *
-     * @internal
+     * @returns {qx.core.Object} the source object
      */
-    updateTarget(
-      sourceObject,
-      sourcePropertyChain,
-      targetObject,
-      targetPropertyChain,
-      options
-    ) {
-      var value = this.resolvePropertyChain(sourceObject, sourcePropertyChain);
-
-      // convert the data before setting
-      value = qx.data.SingleValueBinding.__convertValue(
-        value,
-        targetObject,
-        targetPropertyChain,
-        options,
-        sourceObject
-      );
-
-      this.__setTargetValue(targetObject, targetPropertyChain, value);
+    getSource() {
+      return this.__source;
     },
 
     /**
-     * Internal helper for getting the current set value at the property chain.
-     *
-     * @param o {qx.core.Object} The source of the binding.
-     * @param propertyChain {String} The property chain which represents
-     *   the source property.
-     * @return {var?undefined} Returns the set value if defined.
+     * Apply for `targetPath`
      */
-    resolvePropertyChain(o, propertyChain) {
-      var properties = this.__getPropertyChainArray(propertyChain);
-      return this.__getTargetFromChain(o, properties, properties.length);
+    _applyTargetPath(value, oldValue) {
+      if (oldValue) {
+        throw new Error("Cannot change targetPath after binding has been created");
+      }
+      this.__record = null; // invalidate record representation cache
+      this.__targetSegments = qx.data.SingleValueBinding.__parseSegments(this, value);
+      this.__targetSegments.at(-1).addListener("changeInput", this.__updateTarget, this);
     },
 
     /**
-     * Tries to return a fitting event name to the given source object and
-     * property name. First, it assumes that the property name is a real property
-     * and therefore it checks the property definition for the event. The second
-     * possibility is to check if there is an event with the given name. The
-     * third and last possibility checked is if there is an event which is named
-     * change + propertyName. If this three possibilities fail, an error will be
-     * thrown.
+     * Sets the target object of this binding.
+     * If a source is set, the target will be updated with source's value.
      *
-     * @param source {qx.core.Object} The source where the property is stored.
-     * @param propertyName {String} The name of the property.
-     * @return {String|null} The name of the corresponding event or null.
+     * @param {qx.core.Object?} value The source object to get the `value` by looking up `sourcePath`
+     * @returns {Promise?} A promise if any stage of the process was asynchronous, i.e. we had to get a property asynchronously along the source/target path,
+     * or setting the target was asynchronous.
+     * If everything was synchronous, then this will return null.
      */
-    __getEventNameForProperty(source, propertyName) {
-      // get the current event name from the property definition
-      var eventName = this.__getEventForProperty(source, propertyName);
-      // if no event name could be found
-      if (eventName == null) {
-        // check if the propertyName is the event name
-        if (qx.Class.supportsEvent(source.constructor, propertyName)) {
-          eventName = propertyName;
-          // check if the change + propertyName is the event name
-        } else if (
-          qx.Class.supportsEvent(
-            source.constructor,
-            "change" + qx.lang.String.firstUp(propertyName)
-          )
-        ) {
-          eventName = "change" + qx.lang.String.firstUp(propertyName);
-        } else {
-          return null;
-        }
+    setTarget(value) {
+      if (this.__target === value) {
+        return;
       }
-      return eventName;
-    },
 
-    /**
-     * Resets the value of the given target after resolving the target property
-     * chain.
-     *
-     * @param targetObject {qx.core.Object} The object where the property chain
-     *   starts.
-     * @param targetPropertyChain {String} The names of the properties,
-     *   separated with a dot.
-     */
-    __resetTargetValue(targetObject, targetPropertyChain) {
-      // get the last target object of the chain
-      var properties = this.__getPropertyChainArray(targetPropertyChain);
-      var target = this.__getTargetFromChain(targetObject, properties);
-      if (target != null) {
-        // get the name of the last property
-        var lastProperty = properties[properties.length - 1];
-        // check for an array and set the value to null
-        var index = this.__getArrayIndex(lastProperty);
-        if (index) {
-          this.__setTargetValue(targetObject, targetPropertyChain, null);
-          return;
-        }
+      this.__record = null; // invalidate record representation cache
+      this.__initPromise = null; // reset the init promise, as the target has changed
+      let oldValue = this.__target;
+      this.__target = value;
+      const SingleValueBinding = qx.data.SingleValueBinding;
 
-        // try to reset the property
-        if (
-          target["reset" + qx.lang.String.firstUp(lastProperty)] != undefined
-        ) {
-          target["reset" + qx.lang.String.firstUp(lastProperty)]();
-        } else {
-          // fallback if no resetter is given (see bug #2456)
-          if (
-            typeof target["set" + qx.lang.String.firstUp(lastProperty)] !=
-            "function"
-          ) {
-            throw new qx.core.AssertionError(
-              "No setter for '" + lastProperty + "' on target " + target + "."
-            );
-          }
-          target["set" + qx.lang.String.firstUp(lastProperty)](null);
+      if (oldValue) {
+        delete SingleValueBinding.__bindingsByTarget[oldValue.toHashCode()][this.toHashCode()];
+        if (qx.lang.Object.isEmpty(SingleValueBinding.__bindingsByTarget[oldValue.toHashCode()])) {
+          delete SingleValueBinding.__bindingsByTarget[oldValue.toHashCode()];
         }
       }
-    },
 
-    /**
-     * Sets the given value to the given target after resolving the
-     * target property chain.
-     *
-     * @param targetObject {qx.core.Object} The object where the property chain
-     *   starts.
-     * @param targetPropertyChain {String} The names of the properties,
-     *   separated with a dot.
-     * @param value {var} The value to set.
-     */
-    __setTargetValue(targetObject, targetPropertyChain, value) {
-      // get the last target object of the chain
-      var properties = this.__getPropertyChainArray(targetPropertyChain);
-      var target = this.__getTargetFromChain(targetObject, properties);
-      if (target) {
-        // get the name of the last property
-        var lastProperty = properties[properties.length - 1];
-
-        // check for array notation
-        var index = this.__getArrayIndex(lastProperty);
-        if (index) {
-          if (index === "last") {
-            // check for the 'last' notation
-            index = target.length - 1;
-          }
-          target.setItem(index, value);
-        } else {
-          if (
-            typeof target["set" + qx.lang.String.firstUp(lastProperty)] !=
-            "function"
-          ) {
-            throw new qx.core.AssertionError(
-              "No setter for '" + lastProperty + "' on target " + target + "."
-            );
-          }
-          return target["set" + qx.lang.String.firstUp(lastProperty)](value);
-        }
+      if (value) {
+        const SingleValueBinding = qx.data.SingleValueBinding;
+        SingleValueBinding.__bindingsByTarget[value.toHashCode()] ??= {};
+        SingleValueBinding.__bindingsByTarget[value.toHashCode()][this.toHashCode()] = this;
+
+        let out = this.__targetSegments[0].setInput(value);
+        this.__initPromise = Promise.resolve(out);
+        return out;
       }
     },
 
     /**
-     * Returns the index from a property using bracket notation, e.g.
-     * "[42]" returns "42", "[last]" returns "last"
      *
-     * @param propertyName {String} A property name
-     * @return {String|null} Array index or null if the property name does
-     * not use bracket notation
+     * @returns {qx.core.Object} the target object
      */
-    __getArrayIndex(propertyName) {
-      var arrayExp = /^\[(\d+|last)\]$/;
-      var arrayMatch = propertyName.match(arrayExp);
-      if (arrayMatch) {
-        return arrayMatch[1];
-      }
-      return null;
+    getTarget() {
+      return this.__target;
     },
 
     /**
-     * Converts a property chain string into a list of properties and/or
-     * array indexes
-     * @param targetPropertyChain {String} property chain
-     * @return {String[]} Array of property names
+     * This method should not be called directly.
+     * It is only there to comply with interface `qx.data.binding.IInputReceiver`.
+     * @override interface qx.data.binding.IInputReceiver
+     *
+     * @param {*} input
      */
-    __getPropertyChainArray(targetPropertyChain) {
-      // split properties (dot notation) and array indexes (bracket notation)
-      return targetPropertyChain
-        .replace(/\[/g, ".[")
-        .split(".")
-        .filter(function (prop) {
-          return prop !== "";
-        });
+    setInput(input) {
+      return this.__setValue(input);
     },
 
     /**
-     * Helper-Function resolving the object on which the last property of the
-     * chain should be set.
      *
-     * @param targetObject {qx.core.Object} The object where the property chain
-     *   starts.
-     * @param targetProperties {String[]} Array containing the names of the properties
-     * @param index {Number?} The array index of the last property to be considered.
-     * Default: The last item's index
-     * @return {qx.core.Object|null} The object on which the last property
-     *   should be set.
+     * @param {*} value The final value obtained from the sourcePath
+     * @returns {Promise?} A promise if setting the target is asynchronous, otherwise null
      */
-    __getTargetFromChain(targetObject, targetProperties, index) {
-      index = index || targetProperties.length - 1;
-      var target = targetObject;
-
-      for (var i = 0; target !== null && i < index; i++) {
-        try {
-          var property = targetProperties[i];
-
-          // array notation
-          var arrIndex = this.__getArrayIndex(property);
-          if (arrIndex) {
-            if (arrIndex === "last") {
-              // check for the 'last' notation
-              arrIndex = target.length - 1;
-            }
-            target = target.getItem(arrIndex);
-          } else {
-            target = target["get" + qx.lang.String.firstUp(property)]();
-          }
-        } catch (ex) {
-          return null;
-        }
+    __setValue(value) {
+      if (this.__value === value) {
+        return null; // no change
       }
-      return target;
+      this.__value = value;
+      return this.__updateTarget();
     },
 
     /**
-     * Set the given value to the target property. This method is used for
-     * initially set the value.
      *
-     * @param value {var} The value to set.
-     * @param targetObject {qx.core.Object} The object which contains the target
-     *   property.
-     * @param targetPropertyChain {String} The name of the target property in the
-     *   target object.
-     * @param options {Map} The options map perhaps containing the user defined
-     *   converter.
-     * @param sourceObject {qx.core.Object} The source object of the binding (
-     *   used for the onUpdate callback).
+     * @returns {*} the value that was set by the sourcePath
      */
-    __setInitialValue(
-      value,
-      targetObject,
-      targetPropertyChain,
-      options,
-      sourceObject
-    ) {
-      // first convert the initial value
-      value = this.__convertValue(
-        value,
-        targetObject,
-        targetPropertyChain,
-        options,
-        sourceObject
-      );
-
-      // check if the converted value is undefined
-      if (value === undefined) {
-        this.__resetTargetValue(targetObject, targetPropertyChain);
-      }
-      // only set the initial value if one is given (may be null)
-      if (value !== undefined) {
-        try {
-          var result = this.__setTargetValue(
-            targetObject,
-            targetPropertyChain,
-            value
-          );
-
-          // tell the user that the setter was invoked probably
-          if (options && options.onUpdate) {
-            options.onUpdate(sourceObject, targetObject, value);
-          }
-          return result;
-        } catch (e) {
-          if (!(e instanceof qx.core.ValidationError)) {
-            throw e;
-          }
-
-          if (options && options.onSetFail) {
-            options.onSetFail(e);
-          } else {
-            qx.log.Logger.warn(
-              "Failed so set value " +
-                value +
-                " on " +
-                targetObject +
-                ". Error message: " +
-                e
-            );
-          }
-        }
-      }
+    getValue() {
+      return this.__value;
     },
 
     /**
-     * Checks for an array element in the given property names and adapts the
-     * arrays to fit the algorithm.
-     *
-     * @param propertyNames {Array} The array containing the property names.
-     *   Attention, this method can change this parameter!!!
-     * @return {Array} An array containing the values of the array properties
-     *   corresponding to the property names.
+     * Updates the target with the current value
      */
-    __checkForArrayInPropertyChain(propertyNames) {
-      // array for the values of the array properties
-      var arrayIndexValues = [];
-
-      // go through all properties and check for array notations
-      for (var i = 0; i < propertyNames.length; i++) {
-        var name = propertyNames[i];
-        // if its an array property in the chain
-        if (name.endsWith("]")) {
-          // get the inner value of the array notation
-          var arrayIndex = name.substring(
-            name.indexOf("[") + 1,
-            name.indexOf("]")
-          );
-
-          // check the arrayIndex
-          if (name.indexOf("]") != name.length - 1) {
-            throw new Error(
-              "Please use only one array at a time: " + name + " does not work."
-            );
+    __updateTarget() {
+      if (this.__targetSegments) {
+        //We need to make sure the target segments are up to date
+        //because the listeners may trigger after this point.
+        //This is important in bidirectional bindings.
+        for (let segment of this.__targetSegments) {
+          if (segment.getOutputReceiver()) {
+            segment.updateOutput();
           }
-          if (arrayIndex !== "last") {
-            if (arrayIndex == "" || isNaN(parseInt(arrayIndex, 10))) {
-              throw new Error(
-                "No number or 'last' value has been given" +
-                  " in an array binding: " +
-                  name +
-                  " does not work."
-              );
-            }
-          }
-
-          // if a property is in front of the array notation
-          if (name.indexOf("[") != 0) {
-            // store the property name without the array notation
-            propertyNames[i] = name.substring(0, name.indexOf("["));
-            // store the values in the array for the current iteration
-            arrayIndexValues[i] = "";
-            // store the properties for the next iteration (the item of the array)
-            arrayIndexValues[i + 1] = arrayIndex;
-            propertyNames.splice(i + 1, 0, "item");
-            // skip the next iteration. its the array item and its already set
-            i++;
-            // it the array notation is the beginning
-          } else {
-            // store the array index and override the entry in the property names
-            arrayIndexValues[i] = arrayIndex;
-            propertyNames.splice(i, 1, "item");
-          }
-        } else {
-          arrayIndexValues[i] = "";
         }
       }
 
-      return arrayIndexValues;
-    },
-
-    /**
-     * Internal helper method which is actually doing all bindings. That means
-     * that an event listener will be added to the source object which listens
-     * to the given event and invokes an set on the target property on the
-     * targetObject.
-     * This method does not store the binding in the internal reference store
-     * so it should NOT be used from outside this class. For an outside usage,
-     * use {@link #bind}.
-     *
-     * @param sourceObject {qx.core.Object} The source of the binding.
-     * @param sourceEvent {String} The event of the source object which could
-     *   be the change event in common but has to be an
-     *   {@link qx.event.type.Data} event.
-     * @param targetObject {qx.core.Object} The object which the source should
-     *   be bind to.
-     * @param targetProperty {String} The property name of the target object.
-     * @param options {Map} A map containing the options. See
-     *   {@link #bind} for more information.
-     * @param arrayIndex {String} The index of the given array if its an array
-     *   to bind.
-     *
-     * @return {var} Returns the internal id for that binding. This can be used
-     *   for referencing the binding or e.g. for removing. This is not an atomic
-     *   id so you can't you use it as a hash-map index. It's the id which will
-     *   be returned by the {@link qx.core.Object#addListener} method.
-     * @throws {qx.core.AssertionError} If the event is no data event or
-     *   there is no property definition for the target object and target
-     *   property.
-     */
-    __bindEventToProperty(
-      sourceObject,
-      sourceEvent,
-      targetObject,
-      targetProperty,
-      options,
-      arrayIndex
-    ) {
-      // checks
-      if (qx.core.Environment.get("qx.debug")) {
-        // check for the data event
-        var eventType = qx.Class.getEventType(
-          sourceObject.constructor,
-          sourceEvent
-        );
-
-        qx.core.Assert.assertEquals(
-          "qx.event.type.Data",
-          eventType,
-          sourceEvent +
-            " is not an data (qx.event.type.Data) event on " +
-            sourceObject +
-            "."
-        );
-      }
-
-      var bindListener = function (arrayIndex, e) {
-        // if an array value is given
-        if (arrayIndex !== "") {
-          //check if its the "last" value
-          if (arrayIndex === "last") {
-            arrayIndex = sourceObject.length - 1;
-          }
+      let lastSegment = this.__targetSegments.at(-1);
 
-          // get the data of the array
-          var data = sourceObject.getItem(arrayIndex);
+      if (this.getTarget() && this.getSource()) {
+        let value = this.getValue();
 
-          // reset the target if the data is not set
-          if (data === undefined) {
-            qx.data.SingleValueBinding.__resetTargetValue(
-              targetObject,
-              targetProperty
-            );
-          }
-
-          // only do something if the current array has been changed
-          var start = e.getData().start;
-          var end = e.getData().end;
-          if (arrayIndex < start || arrayIndex > end) {
-            return;
-          }
-        } else {
-          // get the data out of the event
-          var data = e.getData();
+        let ignoreConverter = false;
+        if (this.__options.ignoreConverter) {
+          var match = this.getSourcePath().match(new RegExp("^" + this.__options.ignoreConverter));
+          ignoreConverter = match ? match.length > 0 : false;
         }
 
-        // debug message
-        if (qx.core.Environment.get("qx.debug.databinding")) {
-          qx.log.Logger.debug(
-            "Binding executed from " +
-              sourceObject +
-              " by " +
-              sourceEvent +
-              " to " +
-              targetObject +
-              " (" +
-              targetProperty +
-              ")"
-          );
-
-          qx.log.Logger.debug("Data before conversion: " + data);
+        if (this.__options.converter && (value !== undefined || !ignoreConverter)) {
+          let model = typeof this.getTarget().getModel == "function" ? this.getTarget().getModel() : null;
+          value = this.__options.converter(value, model, this.getSource(), this.getTarget());
         }
 
-        // convert the data
-        data = qx.data.SingleValueBinding.__convertValue(
-          data,
-          targetObject,
-          targetProperty,
-          options,
-          sourceObject
-        );
-
-        // debug message
-        if (qx.core.Environment.get("qx.debug.databinding")) {
-          qx.log.Logger.debug("Data after conversion: " + data);
-        }
-
-        // try to set the value
-        var result;
-        try {
-          if (data !== undefined) {
-            result = qx.data.SingleValueBinding.__setTargetValue(
-              targetObject,
-              targetProperty,
-              data
-            );
+        const cb = ex => {
+          if (ex) {
+            this.__options.onSetFail?.();
           } else {
-            result = qx.data.SingleValueBinding.__resetTargetValue(
-              targetObject,
-              targetProperty
-            );
+            this.__options.onUpdate?.(this.getSource(), this.getTarget(), value);
           }
+          return null;
+        };
 
-          // tell the user that the setter was invoked probably
-          if (options && options.onUpdate) {
-            options.onUpdate(sourceObject, targetObject, data);
-          }
+        let ret;
+        try {
+          ret = lastSegment.setTargetValue(value);
         } catch (ex) {
-          if (!(ex instanceof qx.core.ValidationError)) {
-            throw ex;
-          }
-
-          if (options && options.onSetFail) {
-            options.onSetFail(ex);
-          } else {
-            qx.log.Logger.warn(
-              "Failed so set value " +
-                data +
-                " on " +
-                targetObject +
-                ". Error message: " +
-                ex
-            );
-          }
+          return cb(ex);
         }
-        return result;
-      };
 
-      // check if an array index is given
-      if (!arrayIndex) {
-        // if not, signal it a s an empty string
-        arrayIndex = "";
+        if (qx.Promise.isPromise(ret)) {
+          return ret.then(cb, cb);
+        } else {
+          cb(null);
+        }
       }
-      // bind the listener function (make the array index in the listener available)
-      bindListener = qx.lang.Function.bind(
-        bindListener,
-        sourceObject,
-        arrayIndex
-      );
+    }
+  },
 
-      // add the listener
-      var id = sourceObject.addListener(sourceEvent, bindListener);
+  statics: {
+    /** @type {Object<String,Object<String,Binding>>} map of maps, outer map is indexed by object hash, inner is indexed by binding hash */
+    __bindingsBySource: {},
 
-      return id;
-    },
+    /** @type {Object<String,Object<String,Binding>>} map of maps, outer map is indexed by object hash, inner is indexed by binding hash */
+    __bindingsByTarget: {},
 
     /**
-     * This method stores the given value as a binding in the internal structure
-     * of all bindings.
-     *
-     * @param id {var} The listener id of the id for a deeper binding.
-     * @param sourceObject {qx.core.Object} The source Object of the binding.
-     * @param sourceEvent {String} The name of the source event.
-     * @param targetObject {qx.core.Object} The target object.
-     * @param targetProperty {String} The name of the property on the target
-     *   object.
+     * @see {qx.data.SingleValueBinding#construct}
      */
-    __storeBinding(
-      id,
-      sourceObject,
-      sourceEvent,
-      targetObject,
-      targetProperty
-    ) {
-      var hash;
-
-      // add the listener id to the internal registry
-      hash = sourceObject.toHashCode();
-      if (this.__bindings[hash] === undefined) {
-        this.__bindings[hash] = [];
+    bind(sourceObject, sourcePropertyChain, targetObject, targetPropertyChain, options) {
+      // check for the arguments
+      if (qx.core.Environment.get("qx.debug")) {
+        qx.core.Assert.assertObject(sourceObject, "sourceObject");
+        qx.core.Assert.assertString(sourcePropertyChain, "sourcePropertyChain");
+        qx.core.Assert.assertObject(targetObject, "targetObject");
+        qx.core.Assert.assertString(targetPropertyChain, "targetPropertyChain");
       }
 
-      var binding = [
-        id,
-        sourceObject,
-        sourceEvent,
-        targetObject,
-        targetProperty
-      ];
-
-      this.__bindings[hash].push(binding);
+      let binding = new qx.data.SingleValueBinding(sourcePropertyChain, targetPropertyChain, sourceObject, targetObject, options);
 
-      // add same binding data indexed by target object
-      hash = targetObject.toHashCode();
-      if (this.__bindingsByTarget[hash] === undefined) {
-        this.__bindingsByTarget[hash] = [];
-      }
-      this.__bindingsByTarget[hash].push(binding);
+      return binding;
     },
 
     /**
-     * This method takes the given value, checks if the user has given a
-     * converter and converts the value to its target type. If no converter is
-     * given by the user, the {@link #__defaultConversion} will try to convert
-     * the value.
-     *
-     * @param value {var} The value which possibly should be converted.
-     * @param targetObject {qx.core.Object} The target object.
-     * @param targetPropertyChain {String} The property name of the target object.
-     * @param options {Map} The options map which can includes the converter.
-     *   For a detailed information on the map, take a look at
-     *   {@link #bind}.
-     * @param sourceObject {qx.core.Object} The source object for the binding.
+     * Removes the binding with the given id from the given sourceObject. The
+     * id has to be the id returned by any of the bind functions.
      *
-     * @return {var} The converted value. If no conversion has been done, the
-     *   value property will be returned.
-     * @throws {qx.core.AssertionError} If there is no property definition
-     *   of the given target object and target property.
+     * @param sourceObject {qx.core.Object} The source object of the binding.
+     * @param id {var} The id of the binding.
+     * @throws {Error} If the binding could not be found.
      */
-    __convertValue(
-      value,
-      targetObject,
-      targetPropertyChain,
-      options,
-      sourceObject
-    ) {
-      // do the conversion given by the user
-      if (options && options.converter) {
-        var model;
-        if (targetObject.getModel) {
-          model = targetObject.getModel();
-        }
-        return options.converter(value, model, sourceObject, targetObject);
-        // try default conversion
-      } else {
-        var properties = this.__getPropertyChainArray(targetPropertyChain);
-        var target = this.__getTargetFromChain(targetObject, properties);
-        var lastProperty = targetPropertyChain.substring(
-          targetPropertyChain.lastIndexOf(".") + 1,
-          targetPropertyChain.length
-        );
-
-        // if no target is currently available, return the original value
-        if (target == null) {
-          return value;
-        }
-
-        var propertieDefinition = qx.Class.getPropertyDefinition(
-          target.constructor,
-          lastProperty
-        );
-
-        var check =
-          propertieDefinition == null ? "" : propertieDefinition.check;
-        return this.__defaultConversion(value, check);
-      }
+    removeBindingFromObject(sourceObject, binding) {
+      binding.dispose();
     },
 
     /**
-     * Helper method which tries to figure out if the given property on the
-     * given object does have a change event and if returns the name of it.
+     * Removes all bindings for the given object.
      *
-     * @param sourceObject {qx.core.Object} The object to check.
-     * @param sourceProperty {String} The name of the property.
+     * @param object {qx.core.Object} The object of which the bindings should be
+     *   removed.
+     * @throws {qx.core.AssertionError} If the object is not in the internal
+     *   registry of the bindings.
+     * @throws {Error} If one of the bindings listed internally can not be
+     *   removed.
+     */
+    removeAllBindingsForObject(object) {
+      qx.core.Assert.assertNotNull(object, "Null is not possible!");
+      qx.data.SingleValueBinding.getAllBindingsForObject(object).forEach(binding => binding[0].dispose());
+    },
+
+    /**
+     * Debug function which shows some valuable information about the given
+     * binding in console. For that it uses {@link qx.log.Logger}.
      *
-     * @return {String} The name of the change event.
-     * @throws {qx.core.AssertionError} If there is no property definition of
-     *   the given object property pair.
+     * @param object {qx.core.Object} the source of the binding.
+     * @param id {var} The id of the binding.
      */
-    __getEventForProperty(sourceObject, sourceProperty) {
-      // get the event name
-      var propertieDefinition = qx.Class.getPropertyDefinition(
-        sourceObject.constructor,
-        sourceProperty
+    showBindingInLog(object, binding) {
+      qx.log.Logger.debug(
+        "Binding from '" +
+          binding.getSource() +
+          "' (" +
+          binding.getSourcePath() +
+          ") to the object '" +
+          binding.getTarget() +
+          "' (" +
+          binding.getTargetPath() +
+          ")."
       );
-
-      if (propertieDefinition == null) {
-        return null;
-      }
-      return propertieDefinition.event;
     },
 
     /**
-     * Tries to convert the data to the type given in the targetCheck argument.
+     * Helper for updating the target. Gets the current set data from the source
+     * and set that on the target.
      *
-     * @param data {var} The data to convert.
-     * @param targetCheck {String} The value of the check property. That usually
-     *   contains the target type.
-     * @return {Integer|String|Float} The converted data
+     * @param sourceObject {qx.core.Object} The source of the binding.
+     * @param sourcePropertyChain {String} The property chain which represents
+     *   the source property.
+     * @param targetObject {qx.core.Object} The object which the source should
+     *   be bind to.
+     * @param targetPropertyChain {String} The property name of the target
+     *   object.
+     * @param options {Map} The options map perhaps containing the user defined
+     *   converter.
+     *
+     * @internal
      */
-    __defaultConversion(data, targetCheck) {
-      var dataType = qx.lang.Type.getClass(data);
-
-      // to integer
-      if (
-        (dataType == "Number" || dataType == "String") &&
-        (targetCheck == "Integer" || targetCheck == "PositiveInteger")
-      ) {
-        data = parseInt(data, 10);
-      }
-
-      // to string
-      if (
-        (dataType == "Boolean" || dataType == "Number" || dataType == "Date") &&
-        targetCheck == "String"
-      ) {
-        data = data + "";
-      }
+    updateTarget(sourceObject, sourcePropertyChain, targetObject, targetPropertyChain, options) {
+      options ??= {};
+      var value = this.resolvePropertyChain(sourceObject, sourcePropertyChain);
 
-      // to float
-      if (
-        (dataType == "Number" || dataType == "String") &&
-        (targetCheck == "Number" || targetCheck == "PositiveNumber")
-      ) {
-        data = parseFloat(data);
+      // convert the data before setting
+      if (options.converter) {
+        let model = typeof targetObject.getModel == "function" ? targetObject.getModel() : null;
+        value = options.converter(value, model, sourceObject, targetObject);
       }
 
-      return data;
+      return this.__setTargetValue(targetObject, targetPropertyChain, value);
     },
 
     /**
-     * Removes the binding with the given id from the given sourceObject. The
-     * id has to be the id returned by any of the bind functions.
+     * Sets the given value to the given target after resolving the
+     * target property chain.
      *
-     * @param sourceObject {qx.core.Object} The source object of the binding.
-     * @param id {var} The id of the binding.
-     * @throws {Error} If the binding could not be found.
+     * @param targetObject {qx.core.Object} The object where the property chain
+     *   starts.
+     * @param targetPropertyChain {String} The names of the properties,
+     *   separated with a dot.
+     * @param value {var} The value to set.
      */
-    removeBindingFromObject(sourceObject, id) {
-      // check for a deep binding
-      if (id.type == "deepBinding") {
-        // go through all added listeners (source)
-        for (var i = 0; i < id.sources.length; i++) {
-          // check if a source is available
-          if (id.sources[i]) {
-            if (id.listenerIds[i]) {
-              id.sources[i].removeListenerById(id.listenerIds[i]);
-            }
-            // If the listener id is not available, it is most likely
-            // caused by some hidden error situation.
-            // At least an error message should be displayed
-            else {
-              sourceObject.error(
-                "Could not remove deep bindings. Binding id for " +
-                  id.sources[i].classname +
-                  " could not be found!"
-              );
-            }
-          }
-        }
-        // go through all added listeners (target)
-        for (var i = 0; i < id.targets.length; i++) {
-          // check if a target is available
-          if (id.targets[i]) {
-            if (id.targetListenerIds[i]) {
-              id.targets[i].removeListenerById(id.targetListenerIds[i]);
-            }
-            // If the target listener id is not available, it is most likely
-            // caused by some hidden error situation.
-            // At least an error message should be displayed
-            else {
-              sourceObject.error(
-                "Could not remove target listener. Listener id for target " +
-                  id.targets[i].classname +
-                  " could not be found!"
-              );
-            }
-          }
-        }
-      } else {
-        // remove the listener
-        sourceObject.removeListenerById(id);
-      }
+    __setTargetValue(targetObject, targetPropertyChain, value) {
+      let segments = qx.data.SingleValueBinding.__parseSegments(null, targetPropertyChain);
+      let lastSegment = segments[segments.length - 1];
+      segments[0].setInput(targetObject);
+      let out = lastSegment.setTargetValue(value);
+      segments.forEach(segment => segment.dispose());
+      return out;
+    },
 
-      // remove the id from the internal reference system
-      var bindings = this.getAllBindingsForObject(sourceObject);
-      // check if the binding exists
-      if (bindings != undefined) {
-        for (var i = 0; i < bindings.length; i++) {
-          if (bindings[i][0] == id) {
-            // remove binding data from internal reference indexed by target object
-            var target = bindings[i][3];
-            if (this.__bindingsByTarget[target.toHashCode()]) {
-              qx.lang.Array.remove(
-                this.__bindingsByTarget[target.toHashCode()],
-                bindings[i]
-              );
-            }
-
-            // remove binding data from internal reference indexed by source object
-            var source = bindings[i][1];
-            if (this.__bindings[source.toHashCode()]) {
-              qx.lang.Array.remove(
-                this.__bindings[source.toHashCode()],
-                bindings[i]
-              );
-            }
-            return;
-          }
+    /**
+     * Splits a property path into segments.
+     * @param {string} path
+     * @returns {string[]} an array of segments, split by dot and square brackets.
+     * For example, splitSegments(`a.b[0].c`) will return `["a", "b", "[0]", "c"]`
+     */
+    splitSegments(path) {
+      let out = [];
+      for (let dotSplit of path.split(".")) {
+        let bracketSplits = dotSplit.split("[");
+        for (let i = 0; i < bracketSplits.length; i++) {
+          let bracketSplit = bracketSplits[i];
+          if (i > 0) {
+            bracketSplit = "[" + bracketSplit;
+          }
+          out.push(bracketSplit);
         }
       }
-      throw new Error("Binding could not be found!");
+      return out.filter(s => s.length > 0);
     },
 
     /**
-     * Removes all bindings for the given object.
+     * Finds all bindings for an object, as either a source or target
      *
-     * @param object {qx.core.Object} The object of which the bindings should be
-     *   removed.
-     * @throws {qx.core.AssertionError} If the object is not in the internal
-     *   registry of the bindings.
-     * @throws {Error} If one of the bindings listed internally can not be
-     *   removed.
+     * @param {qx.core.Object} object
+     * @returns {BindingRecord[]} An array of the bindings represented as records.
      */
-    removeAllBindingsForObject(object) {
-      // check for the null value
+    getAllBindingsForObject(object) {
+      const SingleValueBinding = qx.data.SingleValueBinding;
+      let allBindings = {
+        ...(SingleValueBinding.__bindingsBySource[object.toHashCode()] ?? {}),
+        ...(SingleValueBinding.__bindingsByTarget[object.toHashCode()] ?? {})
+      };
+      return Object.values(allBindings).map(binding => binding.asRecord());
+    },
 
-      if (qx.core.Environment.get("qx.debug")) {
-        qx.core.Assert.assertNotNull(
-          object,
-          "Can not remove the bindings for null object!"
-        );
-      }
+    /**
+     * Returns a map containing for every bound object an array of data binding
+     * information. The key of the map is the hash code of the bound objects.
+     * Every binding is represented by an array containing id, sourceObject,
+     * sourceEvent, targetObject and targetProperty.
+     *
+     * @return {Object<string, BindingInfo>} Map containing all bindings.
+     *
+     * @typedef {[qx.data.SingleValueBinding, qx.core.Object, string, qx.core.Object, string]} BindingInfo
+     * Stores the binding ID, source object, source path, target object and target path respectively.
+     */
+    getAllBindings() {
+      let bindings = qx.data.SingleValueBinding.__bindingsBySource;
 
-      // get the bindings
-      var bindings = this.getAllBindingsForObject(object);
-      if (bindings != undefined) {
-        // remove every binding with the removeBindingFromObject function
-        for (var i = bindings.length - 1; i >= 0; i--) {
-          this.removeBindingFromObject(object, bindings[i][0]);
+      let result = {};
+      for (let [objectHash, objectBindings] of Object.entries(bindings)) {
+        let objectBindingsArray = [];
+        for (let [bindingHash, binding] of Object.entries(objectBindings)) {
+          objectBindingsArray.push([binding, binding.getSource(), binding.getSourcePath(), binding.getTarget(), binding.getTargetPath()]);
         }
+        result[objectHash] = objectBindingsArray;
       }
-
-      var hash = object.toHashCode();
-      delete this.__bindings[hash];
-      delete this.__bindingsByTarget[hash];
+      return result;
     },
 
     /**
@@ -1561,149 +651,158 @@ qx.Class.define("qx.data.SingleValueBinding", {
      *   removed.
      */
     removeRelatedBindings(object, relatedObject) {
-      // check for the null value
-      if (qx.core.Environment.get("qx.debug")) {
-        qx.core.Assert.assertNotNull(
-          object,
-          "Can not remove the bindings for null object!"
-        );
-
-        qx.core.Assert.assertNotNull(
-          relatedObject,
-          "Can not remove the bindings for null object!"
-        );
+      const SingleValueBinding = qx.data.SingleValueBinding;
+
+      let bySourceObject = SingleValueBinding.__bindingsBySource[object.toHashCode()];
+
+      if (bySourceObject) {
+        Object.values(bySourceObject).forEach(binding => {
+          if (binding.getTarget() === relatedObject) {
+            binding.dispose();
+          }
+        });
       }
 
-      // get the bindings
-      var bindings = this.getAllBindingsForObject(object);
-      if (bindings != undefined) {
-        // remove every binding with the removeBindingFromObject function
-        for (var i = bindings.length - 1; i >= 0; i--) {
-          var source = bindings[i][1];
-          var target = bindings[i][3];
-          if (source === relatedObject || target === relatedObject) {
-            this.removeBindingFromObject(object, bindings[i][0]);
+      let byRelatedObject = SingleValueBinding.__bindingsBySource[relatedObject.toHashCode()];
+      if (byRelatedObject) {
+        Object.values(byRelatedObject).forEach(binding => {
+          if (binding.getTarget() === object) {
+            binding.dispose();
           }
-        }
+        });
       }
     },
 
     /**
-     * Returns an array which lists all bindings.
+     * Helper method that sets a value for a named property
      *
-     * @param object {qx.core.Object} The object of which the bindings should
-     *   be returned.
-     *
-     * @return {Array} An array of binding informations. Every binding
-     *   information is an array itself containing id, sourceObject,
-     *   sourceEvent, targetObject and targetProperty in that order.
+     * @param {qx.core.Object} target object to have a property set
+     * @param {String} propertyName the name of the property
+     * @param {Object?} value the value to set
      */
-    getAllBindingsForObject(object) {
-      var hash = object.toHashCode();
-
-      // get all bindings of object as source
-      var sourceBindings = this.__bindings[hash];
-
-      // get all bindings of object as target
-      var targetBindings = this.__bindingsByTarget[hash];
-
-      if (!sourceBindings && !targetBindings) {
-        return [];
-      }
-      if (!sourceBindings) {
-        return qx.lang.Array.clone(targetBindings);
-      }
-      if (!targetBindings) {
-        return qx.lang.Array.clone(sourceBindings);
+    set(target, propertyName, value) {
+      let prop = qx.util.PropertyUtil.getProperty(target.constructor, propertyName);
+      if (!prop) {
+        let setFuncName = "set" + qx.lang.String.firstUp(propertyName);
+        if (typeof target[setFuncName] == "function") {
+          return target[setFuncName](value);
+        } else {
+          throw new Error(`Property ${propertyName} not found on ${target.classname}`);
+        }
       }
 
-      return qx.lang.Array.unique(sourceBindings.concat(targetBindings));
+      if (prop.isAsync()) {
+        return prop.setAsync(target, value);
+      } else {
+        return prop.set(target, value);
+      }
     },
 
     /**
-     * Removes all binding in the whole application. After that not a single
-     * binding is left.
-     * @deprecated {6.0} dispose and destructors are deprecated because of automatic memory management; this
-     * will only work for objects explicitly registered with ObjectRegistry.register
+     * Helper method to get a value of a named property
+     *
+     * @param {qx.core.Object} target object to have a property get
+     * @param {String} propertyName the name of the property
+     * @returns {Object?} the property value
      */
-    removeAllBindings() {
-      // go through all registered objects
-      for (var hash in this.__bindings) {
-        var object = qx.core.ObjectRegistry.fromHashCode(hash);
-        // check for the object, perhaps its already deleted
-        if (object == null) {
-          delete this.__bindings[hash];
-          continue;
-        }
-        this.removeAllBindingsForObject(object);
+    get(target, propertyName) {
+      let prop = qx.util.PropertyUtil.getProperty(target.constructor, propertyName);
+      if (prop.isAsync()) {
+        return prop.getAsync(target);
+      } else {
+        return prop.get(target);
       }
-      // reset the bindings map
-      this.__bindings = {};
     },
 
     /**
-     * Returns a map containing for every bound object an array of data binding
-     * information. The key of the map is the hash code of the bound objects.
-     * Every binding is represented by an array containing id, sourceObject,
-     * sourceEvent, targetObject and targetProperty.
+     * Helper method that resets a named property
      *
-     * @return {Map} Map containing all bindings.
+     * @param {qx.core.Object} target object to have a property set
+     * @param {String} propertyName the name of the property
+     
      */
-    getAllBindings() {
-      return this.__bindings;
+    reset(target, propertyName) {
+      let prop = qx.util.PropertyUtil.getProperty(target.constructor, propertyName);
+      if (!prop) {
+        let setFuncName = "reset" + qx.lang.String.firstUp(propertyName);
+        if (typeof target[setFuncName] == "function") {
+          return target[setFuncName]();
+        } else {
+          throw new Error(`Property ${propertyName} not found on ${target.classname}`);
+        }
+      }
+
+      if (prop.isAsync()) {
+        return prop.resetAsync(target);
+      } else {
+        return prop.reset(target);
+      }
     },
 
     /**
-     * Debug function which shows some valuable information about the given
-     * binding in console. For that it uses {@link qx.log.Logger}.
      *
-     * @param object {qx.core.Object} the source of the binding.
-     * @param id {var} The id of the binding.
+     * Internal helper for getting the current set value at the property chain.
+     *
+     * @param {qx.core.Object} object  The source of the binding.
+     * @param {String} propertyChain The property chain which represents
+     *   the source property.
+     * @return {var?undefined} Returns the set value if defined.
      */
-    showBindingInLog(object, id) {
-      var binding;
-      // go through all bindings of the given object
-      for (var i = 0; i < this.__bindings[object.toHashCode()].length; i++) {
-        // the first array item is the id
-        if (this.__bindings[object.toHashCode()][i][0] == id) {
-          binding = this.__bindings[object.toHashCode()][i];
-          break;
+    resolvePropertyChain(object, propertyChain) {
+      let segments = qx.data.SingleValueBinding.__parseSegments(null, propertyChain);
+      let out;
+      let receiver = {
+        setInput(value) {
+          out = value;
         }
-      }
+      };
+      segments.at(-1).setOutputReceiver(receiver);
+      let promise = segments[0].setInput(object);
+
+      const cb = () => {
+        let first = segments[0];
+        if (first instanceof qx.data.binding.PropNameSegment) {
+          let property = qx.Class.getByProperty(object.constructor, first.getPropName());
+          qx.core.Assert.assertNotNull(property, `Object ${object.classname} does not have property ${first.getPropName()}`);
+        }
+        segments.forEach(segment => segment.dispose());
+        return out;
+      };
 
-      if (binding === undefined) {
-        var message = "Binding does not exist!";
+      if (qx.Promise.isPromise(promise)) {
+        return promise.then(cb);
       } else {
-        var message =
-          "Binding from '" +
-          binding[1] +
-          "' (" +
-          binding[2] +
-          ") to the object '" +
-          binding[3] +
-          "' (" +
-          binding[4] +
-          ").";
+        return cb();
       }
-
-      qx.log.Logger.debug(message);
     },
 
     /**
-     * Debug function which shows all bindings in the log console. To get only
-     * one binding in the console use {@link #showBindingInLog}
-     * @deprecated {6.0} qx.core.ObjectRegistry no longer stores most objects
+     * Parses a path and creates an array of `qx.data.binding.AbstractSegment`
+     *
+     * @param {String} path the path to parse
+     * @return {qx.data.binding.AbstractSegment[]?} the new array of segments
      */
-    showAllBindingsInLog() {
-      // go through all objects in the registry
-      for (var hash in this.__bindings) {
-        var object = qx.core.ObjectRegistry.fromHashCode(hash);
-        if (object) {
-          for (var i = 0; i < this.__bindings[hash].length; i++) {
-            this.showBindingInLog(object, this.__bindings[hash][i][0]);
-          }
+    __parseSegments(binding, path) {
+      let segsStrings = qx.data.SingleValueBinding.splitSegments(path);
+      let segments = [];
+
+      for (let seg of segsStrings) {
+        //if it's an array index:
+        if (seg.startsWith("[")) {
+          segments.push(new qx.data.binding.ArrayIndexSegment(binding, seg));
+        } else {
+          //otherwise, it's a normal path
+          segments.push(new qx.data.binding.PropNameSegment(binding, seg));
         }
       }
+
+      segments.forEach((seg, index) => {
+        if (index < segments.length - 1) {
+          seg.setOutputReceiver(segments[index + 1]);
+        }
+      });
+
+      return segments;
     }
   }
 });