docs: function (container, index, howManyRemoved) {
                  var howManyAdded = arguments.length - 3;
  
                  if (!(typeUtils.isArray(container) && typeUtils.isNumber(index) && typeUtils.isNumber(howManyRemoved)
                          && howManyAdded >= 0 && howManyRemoved >= 0)) {
                      this.$logError(this.INVALID_SPLICE_PARAMETERS, [], arguments);
                      return null;
                  }
  
                  // Adapt parameters:
                  var oldLength = container.length;
                  if (index < 0) {
                      // adapt the index value
                      index = oldLength + index;
                      if (index < 0) {
                          index = 0;
                      }
                  }
                  if (index > oldLength) {
                      index = oldLength;
                  }
                  if (index + howManyRemoved > oldLength) {
                      howManyRemoved = oldLength - index;
                  }
                  if (howManyAdded === 0 && howManyRemoved === 0) {
                      // no change
                      return [];
                  }
  
                  // call the splice method from JavaScript:
                  var arrayPrototype = Array.prototype;
                  var removed = arrayPrototype.splice.apply(container, arrayPrototype.slice.call(arguments, 1));
  
                  // do some integrity checks:
                  var newLength = container.length;
                  this.$assert(526, howManyRemoved == removed.length);
                  this.$assert(527, oldLength + howManyAdded - howManyRemoved == newLength);
  
                  // Update back-references:
                  if (container[parProp]) {
                      if (howManyRemoved > 0) {
                          // remove the parent info from the removed items
                          for (var i = howManyRemoved - 1; i >= 0; i--) {
                              __removeLinkToParent(removed[i], container, index + i);
                          }
                      }
                      if (howManyAdded > 0) {
                          // add the parent info to the added items:
                          for (var i = index + howManyAdded - 1; i >= index; i--) {
                              this.__addLinkToParent(container[i], container, i);
                          }
                      }
                      if (howManyAdded != howManyRemoved) {
                          // change the parent info of the moved items
                          for (var newIndex = index + howManyAdded, oldIndex = index + howManyRemoved; newIndex < newLength; newIndex++, oldIndex++) {
                              __changeLinkToParent(container[newIndex], container, oldIndex, newIndex);
                          }
                      }
                  }
  
                  // notify listeners, in two steps:
                  // - first, property-specific listeners, for each index that changed
                  // - then global listeners, to notify about splice change
  
                  var listeners = null;
                  var length = (howManyAdded == howManyRemoved) ? index + howManyAdded : Math.max(oldLength, newLength);
                  for (var i = index; i < length; i++) {
                      listeners = __retrievePropertySpecificListeners(container, i);
                      if (listeners) {
                          var args = {
                              dataHolder : container,
                              dataName : i
                          };
                          if (i >= newLength) {
                              args.change = this.KEY_REMOVED;
                          } else {
                              args.change = this.VALUE_CHANGED;
                              args.newValue = container[i];
                          }
                          if (i < index + howManyRemoved) {
                              // removed value
                              args.oldValue = removed[i - index];
                          } else {
                              // either a moved item, or an item which was beyond the end of the original array
                              args.oldValue = container[i - howManyRemoved + howManyAdded];
                          }
                          __callListeners(listeners, args);
                      }
                  }
  
                  listeners = __retrieveListeners(container); // global listeners (not property-specific)
                  if (listeners) {
                      __callListeners(listeners, {
                          change : this.SPLICE,
                          dataHolder : container,
                          index : index,
                          removed : removed,
                          added : arrayPrototype.slice.call(arguments, 3)
                      });
                  }
  
                  return removed;
              }